diff --git a/Ix/Aiur/Compiler/Check.lean b/Ix/Aiur/Compiler/Check.lean
index fc2dc62b..8c0057d3 100644
--- a/Ix/Aiur/Compiler/Check.lean
+++ b/Ix/Aiur/Compiler/Check.lean
@@ -408,17 +408,18 @@ def zonkTyp (t : Typ) : CheckM Typ := do
   zonkTypBound (s.nextMVar + 1) {} t
 
 /-- Fixed signature of `unconstrainedBigUintDivMod`: the inputs are lists
-of U64 limbs — a pointer to a list datatype instantiated at `[U8; 8]`
-(e.g. `KLimbs = List‹U64›`) — and each result is the SAME list datatype
-instantiated at `[G; 8]`. The result limbs are UNCONSTRAINED prover
-advice, so they must not type as range-checked bytes; consumers rebuild
-`u8` limbs via `u8_range_check` (see `glimbs_to_klimbs` in the IxVM
-kernel). The list's constructor shape is not verified here; the runtime
-BigUint::div_rem faults on a malformed chain. Takes the ZONKED input
-type. -/
+of U64 limbs — a null-pointer-niche list datatype instantiated at
+`[U8; 8]` (e.g. `KLimbs = List‹U64›`, one field element wide: 0 = Nil,
+otherwise a pointer to the `(limb, tail)` cell) — and each result is the
+SAME list datatype instantiated at `[G; 8]`. The result limbs are
+UNCONSTRAINED prover advice, so they must not type as range-checked
+bytes; consumers rebuild `u8` limbs via `u8_range_check` (see
+`glimbs_to_klimbs` in the IxVM kernel). The list's constructor shape is
+not verified here; the runtime BigUint::div_rem faults on a malformed
+chain. Takes the ZONKED input type. -/
 def bigUintDivModResultTyp : Typ → CheckM Typ
-  | .pointer (.app g #[.array .u8 8]) =>
-    pure (.pointer (.app g #[.array .field 8]))
+  | .app g #[.array .u8 8] =>
+    pure (.app g #[.array .field 8])
   | τ => throw $ .unconstrainedBigUintDivModType τ
 
 def instantiateParams (params : List String) : CheckM (Array Typ × (Global → Option Typ)) := do
diff --git a/Ix/Aiur/Compiler/Layout.lean b/Ix/Aiur/Compiler/Layout.lean
index 8e2e4f60..a9a680e2 100644
--- a/Ix/Aiur/Compiler/Layout.lean
+++ b/Ix/Aiur/Compiler/Layout.lean
@@ -29,6 +29,21 @@ the remaining recursion depth. The outer interfaces use `decls.size + 1`
 as bound — the monotonic visited set makes this bound unreachable on
 well-formed inputs. -/
 
+/-- Null-pointer niche (the Aiur analogue of Rust's niche optimization):
+a two-constructor datatype where one constructor is nullary and the other
+carries at least one top-level pointer field. Memory pointers are 1-based
+(0 is the impossible pointer, pinned by the memory circuit), so the
+pointer field doubles as the discriminant — 0 IS the nullary variant —
+and the tag slot is dropped. The nullary variant is represented as the
+all-zero vector; matches dispatch on the pointer slot against 0. -/
+def DataType.hasPointerNiche (dt : DataType) : Bool :=
+  let isPtr : Typ → Bool := fun | .pointer _ => true | _ => false
+  match dt.constructors with
+  | [a, b] =>
+    (a.argTypes.isEmpty && b.argTypes.any isPtr) ||
+    (b.argTypes.isEmpty && a.argTypes.any isPtr)
+  | _ => false
+
 mutual
 
 /-- See `Typ.size` for the outer interface. -/
@@ -70,8 +85,10 @@ def DataType.sizeBound (decls : Decls) : Nat → Std.HashSet Global → DataType
         (Concrete.Constructor.sizeBound decls bound visited)
       let maxFields := ctorSizes.foldl max 0
       -- Single-variant enums need no tag slot: the layout matches a plain
-      -- tuple of the sole constructor's fields.
-      if dt.constructors.length == 1 then pure maxFields
+      -- tuple of the sole constructor's fields. Null-pointer-niche enums
+      -- (see `DataType.hasPointerNiche`) drop the tag as well: the pointer
+      -- field doubles as the discriminant.
+      if dt.constructors.length == 1 || dt.hasPointerNiche then pure maxFields
       else pure (maxFields + 1)
 end
 
diff --git a/Ix/Aiur/Compiler/Lower.lean b/Ix/Aiur/Compiler/Lower.lean
index 275090c4..6c657f14 100644
--- a/Ix/Aiur/Compiler/Lower.lean
+++ b/Ix/Aiur/Compiler/Lower.lean
@@ -34,6 +34,13 @@ structure ConstructorLayout where
   -- True when the parent datatype has a single constructor: no tag slot, so
   -- construction omits the tag const and matches need no discrimination.
   tagless : Bool
+  -- `some slot` when the parent datatype is null-pointer-niche optimized
+  -- (`Concrete.DataType.hasPointerNiche`): no tag slot; `slot` is the
+  -- offset of the discriminating pointer field within the payload
+  -- constructor. The nullary constructor is the all-zero vector (its
+  -- pointer slot is 0, impossible for a real pointer); matches dispatch
+  -- on `slot` with case 0 = nullary and default = payload.
+  niche : Option Nat := none
   deriving Inhabited
 
 inductive Layout
@@ -51,11 +58,25 @@ def Concrete.Decls.layoutMap (decls : Decls) : Except String LayoutMap := do
       let dataTypeSize ← dataType.size decls
       let layoutMap := layoutMap.insert dataType.name (.dataType dataTypeSize)
       let tagless := dataType.constructors.length == 1
+      -- Null-pointer niche: the discriminating slot is the offset of the
+      -- payload constructor's first top-level pointer field.
+      let niche : Option Nat ←
+        if dataType.hasPointerNiche then do
+          let some payload := dataType.constructors.find? (!·.argTypes.isEmpty)
+            | throw s!"hasPointerNiche without payload ctor at `{dataType.name}`"
+          let (slot?, _) ← payload.argTypes.foldlM (init := (none, 0))
+            fun (slot?, off) typ => do
+              let typSyze ← typ.size decls
+              match slot?, typ with
+              | none, .pointer _ => pure (some off, off + typSyze)
+              | _, _ => pure (slot?, off + typSyze)
+          pure slot?
+        else pure none
       let pass := fun (acc, index) constructor => do
         let offsets ← constructor.argTypes.foldlM (init := #[0]) fun offsets typ => do
           let typSyze ← typ.size decls
           pure $ offsets.push ((offsets[offsets.size - 1]?.getD 0) + typSyze)
-        let decl := .constructor { size := dataTypeSize, offsets, index, tagless }
+        let decl := .constructor { size := dataTypeSize, offsets, index, tagless, niche }
         let name := dataType.name.pushNamespace constructor.nameHead
         pure (acc.insert name decl, index + 1)
       let (layoutMap, _) ← dataType.constructors.foldlM pass (layoutMap, 0)
@@ -126,6 +147,69 @@ def pushOp (op : Bytecode.Op) (size : Nat := 1) : CompileM (Array Bytecode.ValId
 def extractOps : CompileM (Array Bytecode.Op) :=
   modifyGet fun s => (s.ops, {s with ops := #[]})
 
+/-- Match-level context for a null-pointer-niche match: the dispatch slot
+(the niche pointer offset) plus which constructor arms the source lists.
+`none` for tagged/tagless matches. The compilation scheme:
+
+- the NULLARY arm becomes case `0` (the impossible-pointer value);
+- the PAYLOAD arm becomes the default arm (its inequality witness against
+  0 exists precisely because real pointers are nonzero);
+- a wildcard (or explicit default) covers whichever constructor is not
+  listed: with a payload arm present it becomes case `0`; with no payload
+  arm it becomes the default; with both constructors listed it is dead
+  and is NOT compiled (a compiled-but-discarded arm would still consume a
+  selector index, desynchronizing the stored selector ids from the
+  layout's selector count). -/
+structure NicheMatchCtx where
+  slot : Nat
+  hasPayload : Bool
+  hasNullary : Bool
+
+def Concrete.nicheMatchCtx (layoutMap : LayoutMap)
+    (cases : Array (Concrete.Pattern × Concrete.Term)) :
+    Option NicheMatchCtx := Id.run do
+  let mut slot? := none
+  let mut hasPayload := false
+  let mut hasNullary := false
+  for (pat, _) in cases do
+    if let .ref g pats := pat then
+      if let some (.constructor layout) := layoutMap[g]? then
+        if let some slot := layout.niche then
+          slot? := some slot
+          if pats.isEmpty then hasNullary := true else hasPayload := true
+  match slot? with
+  | some slot => return some { slot, hasPayload, hasNullary }
+  | none => return none
+
+/-- The value slot a datatype match dispatches on: 0 (the tag slot) for
+tagged layouts, the niche pointer slot for niche layouts. -/
+def Concrete.matchDispatchSlot (layoutMap : LayoutMap)
+    (cases : Array (Concrete.Pattern × Concrete.Term)) : Nat :=
+  match Concrete.nicheMatchCtx layoutMap cases with
+  | some ctx => ctx.slot
+  | none => 0
+
+/-- Synthetic arm for a PARTIAL niche match that lists the payload
+constructor but covers neither the nullary constructor nor a default:
+without it, the nullary value (niche slot 0) would fall through to the
+payload default arm and execute it with garbage bindings. The arm asserts
+`0 = 1` (runtime error, mirroring `MatchNoCase`; in-circuit the arm is
+unsatisfiable). -/
+def Concrete.nicheFailArm (outputSize : Nat) (yieldCtrl : Bool) :
+    CompileM Bytecode.Block := do
+  let initState ← get
+  let z ← pushOp (.const 0)
+  let o ← pushOp (.const 1)
+  let msg := some "niche match: nullary constructor not covered"
+  modify fun s => { s with ops := s.ops.push (.assertEq z o msg) }
+  let ops ← extractOps
+  let selIdx := (← get).selIdx + 1
+  set { initState with selIdx := selIdx }
+  let outs := Array.replicate outputSize (z[0]!)
+  let ctrl := if yieldCtrl then Bytecode.Ctrl.yield (selIdx - 1) outs
+    else Bytecode.Ctrl.return (selIdx - 1) outs
+  pure ({ ops, ctrl } : Bytecode.Block)
+
 open Concrete in
 mutual
 
@@ -156,7 +240,9 @@ def toIndex
       let size := layout.size
       -- Tagless single-variant: no tag slot. A nullary ctor is then a width-0
       -- (unit-like) value; with fields it pads up to `size` from empty.
-      if layout.tagless then
+      -- Niche layouts also carry no tag: the nullary constructor is the
+      -- all-zero vector (pointer slot 0 = impossible pointer).
+      if layout.tagless || layout.niche.isSome then
         if size == 0 then pure #[]
         else
           let padding := (← pushOp (.const (.ofNat 0)))[0]!
@@ -199,9 +285,10 @@ def toIndex
     | some (.constructor layout) => do
       let size := layout.size
       -- Tagless single-variant: omit the tag const; args fill the layout from
-      -- offset 0, exactly like a tuple.
+      -- offset 0, exactly like a tuple. Niche payload constructors likewise:
+      -- no tag, and the pointer field (never 0) is the discriminant.
       let index ←
-        if layout.tagless then pure #[]
+        if layout.tagless || layout.niche.isSome then pure #[]
         else pushOp (.const (.ofNat layout.index))
       let index ← buildArgs layoutMap bindings args index
       if index.size < size then
@@ -413,15 +500,36 @@ def Concrete.Term.compile
       let idxs := bindings[scrut]?.getD #[0]
       let ops ← extractOps
       let (matchCases, defaultBlock) ← cases.foldlM (init := (#[], .none))
-        (Concrete.addCase layoutMap bindings returnTyp idxs (yieldCtrl := true))
-      let defaultBlock ← match defaultOpt with
-        | some t => do
-          let blk ← t.compile returnTyp layoutMap bindings (yieldCtrl := true)
-          pure (some blk)
-        | none => pure defaultBlock
+        (Concrete.addCase layoutMap bindings returnTyp idxs cases (yieldCtrl := true))
+      let (matchCases, defaultBlock) ← match defaultOpt with
+        | some t =>
+          -- Niche matches route an explicit default like a wildcard arm:
+          -- with a payload arm it covers only the nullary constructor
+          -- (case 0; dead and uncompiled if the nullary arm is listed).
+          (match Concrete.nicheMatchCtx layoutMap cases with
+          | some ctx =>
+            if ctx.hasPayload then
+              if ctx.hasNullary then pure (matchCases, defaultBlock)
+              else do
+                let blk ← t.compile returnTyp layoutMap bindings (yieldCtrl := true)
+                pure (matchCases.push ((0 : G), blk), defaultBlock)
+            else do
+              let blk ← t.compile returnTyp layoutMap bindings (yieldCtrl := true)
+              pure (matchCases, some blk)
+          | none => do
+            let blk ← t.compile returnTyp layoutMap bindings (yieldCtrl := true)
+            pure (matchCases, some blk))
+        | none => pure (matchCases, defaultBlock)
       let outputSize ← match typSize layoutMap matchTyp with
         | .error e => throw e
         | .ok n => pure n
+      let matchCases ← match Concrete.nicheMatchCtx layoutMap cases with
+        | some ctx =>
+          if ctx.hasPayload && matchCases.isEmpty && defaultBlock.isSome then do
+            let fail ← Concrete.nicheFailArm outputSize (yieldCtrl := true)
+            pure (matchCases.push ((0 : G), fail))
+          else pure matchCases
+        | none => pure matchCases
       let (sharedAux, sharedLookups) ← Concrete.computeSharedLayout matchCases defaultBlock
       let mergedStart := (← get).valIdx
       modify fun s => { s with
@@ -431,7 +539,7 @@ def Concrete.Term.compile
       let continuation ← bod.compile returnTyp layoutMap
         (bindings.insert var mergedIdxs) yieldCtrl
       let ctrl : Bytecode.Ctrl :=
-        .matchContinue idxs[0]! matchCases defaultBlock outputSize
+        .matchContinue idxs[Concrete.matchDispatchSlot layoutMap cases]! matchCases defaultBlock outputSize
           sharedAux sharedLookups continuation
       pure ({ ops, ctrl } : Bytecode.Block)
   | .letWild _ _ (.match matchTyp valEscapes scrut cases defaultOpt) bod => do
@@ -442,22 +550,43 @@ def Concrete.Term.compile
       let idxs := bindings[scrut]?.getD #[0]
       let ops ← extractOps
       let (matchCases, defaultBlock) ← cases.foldlM (init := (#[], .none))
-        (Concrete.addCase layoutMap bindings returnTyp idxs (yieldCtrl := true))
-      let defaultBlock ← match defaultOpt with
-        | some t => do
-          let blk ← t.compile returnTyp layoutMap bindings (yieldCtrl := true)
-          pure (some blk)
-        | none => pure defaultBlock
+        (Concrete.addCase layoutMap bindings returnTyp idxs cases (yieldCtrl := true))
+      let (matchCases, defaultBlock) ← match defaultOpt with
+        | some t =>
+          -- Niche matches route an explicit default like a wildcard arm:
+          -- with a payload arm it covers only the nullary constructor
+          -- (case 0; dead and uncompiled if the nullary arm is listed).
+          (match Concrete.nicheMatchCtx layoutMap cases with
+          | some ctx =>
+            if ctx.hasPayload then
+              if ctx.hasNullary then pure (matchCases, defaultBlock)
+              else do
+                let blk ← t.compile returnTyp layoutMap bindings (yieldCtrl := true)
+                pure (matchCases.push ((0 : G), blk), defaultBlock)
+            else do
+              let blk ← t.compile returnTyp layoutMap bindings (yieldCtrl := true)
+              pure (matchCases, some blk)
+          | none => do
+            let blk ← t.compile returnTyp layoutMap bindings (yieldCtrl := true)
+            pure (matchCases, some blk))
+        | none => pure (matchCases, defaultBlock)
       let outputSize ← match typSize layoutMap matchTyp with
         | .error e => throw e
         | .ok n => pure n
+      let matchCases ← match Concrete.nicheMatchCtx layoutMap cases with
+        | some ctx =>
+          if ctx.hasPayload && matchCases.isEmpty && defaultBlock.isSome then do
+            let fail ← Concrete.nicheFailArm outputSize (yieldCtrl := true)
+            pure (matchCases.push ((0 : G), fail))
+          else pure matchCases
+        | none => pure matchCases
       let (sharedAux, sharedLookups) ← Concrete.computeSharedLayout matchCases defaultBlock
       modify fun s => { s with
         valIdx := s.valIdx + outputSize,
         degrees := (Array.replicate outputSize 1).foldl (init := s.degrees) (·.push ·) }
       let continuation ← bod.compile returnTyp layoutMap bindings yieldCtrl
       let ctrl : Bytecode.Ctrl :=
-        .matchContinue idxs[0]! matchCases defaultBlock outputSize
+        .matchContinue idxs[Concrete.matchDispatchSlot layoutMap cases]! matchCases defaultBlock outputSize
           sharedAux sharedLookups continuation
       pure ({ ops, ctrl } : Bytecode.Block)
   | .letVar _ _ var val bod => do
@@ -498,13 +627,34 @@ def Concrete.Term.compile
     let idxs := bindings[scrut]?.getD #[0]
     let ops ← extractOps
     let (bcCases, defaultBlock) ← cases.foldlM (init := (#[], .none))
-      (Concrete.addCase layoutMap bindings returnTyp idxs yieldCtrl)
-    let defaultBlock ← match defaultOpt with
-      | some t => do
-        let blk ← t.compile returnTyp layoutMap bindings yieldCtrl
-        pure (some blk)
-      | none => pure defaultBlock
-    let ctrl : Bytecode.Ctrl := .match idxs[0]! bcCases defaultBlock
+      (Concrete.addCase layoutMap bindings returnTyp idxs cases yieldCtrl)
+    let (bcCases, defaultBlock) ← match defaultOpt with
+      | some t =>
+        (match Concrete.nicheMatchCtx layoutMap cases with
+        | some ctx =>
+          if ctx.hasPayload then
+            if ctx.hasNullary then pure (bcCases, defaultBlock)
+            else do
+              let blk ← t.compile returnTyp layoutMap bindings yieldCtrl
+              pure (bcCases.push ((0 : G), blk), defaultBlock)
+          else do
+            let blk ← t.compile returnTyp layoutMap bindings yieldCtrl
+            pure (bcCases, some blk)
+        | none => do
+          let blk ← t.compile returnTyp layoutMap bindings yieldCtrl
+          pure (bcCases, some blk))
+      | none => pure (bcCases, defaultBlock)
+    let bcCases ← match Concrete.nicheMatchCtx layoutMap cases with
+      | some ctx =>
+        if ctx.hasPayload && bcCases.isEmpty && defaultBlock.isSome then do
+          let outputSize ← match typSize layoutMap returnTyp with
+            | .error e => throw e
+            | .ok n => pure n
+          let fail ← Concrete.nicheFailArm outputSize (yieldCtrl := false)
+          pure (bcCases.push ((0 : G), fail))
+        else pure bcCases
+      | none => pure bcCases
+    let ctrl : Bytecode.Ctrl := .match idxs[Concrete.matchDispatchSlot layoutMap cases]! bcCases defaultBlock
     pure ({ ops, ctrl } : Bytecode.Block)
   | .ret _ _ term => do
     let idxs ← toIndex layoutMap bindings term
@@ -536,6 +686,7 @@ def Concrete.addCase
     (bindings : Std.HashMap Local (Array Bytecode.ValIdx))
     (returnTyp : Concrete.Typ)
     (idxs : Array Bytecode.ValIdx)
+    (allCases : Array (Concrete.Pattern × Concrete.Term))
     (yieldCtrl : Bool := false) :
     (Array (G × Bytecode.Block) × Option Bytecode.Block) →
     (Concrete.Pattern × Concrete.Term) →
@@ -548,15 +699,16 @@ def Concrete.addCase
       set { initState with selIdx := (← get).selIdx }
       pure (cases.push (g, term), defaultBlock)
     | .ref global pats => do
-      let (index, offsets, tagless) ← match layoutMap[global]? with
-        | some (.function layout) => pure (layout.index, layout.offsets, false)
-        | some (.constructor layout) => pure (layout.index, layout.offsets, layout.tagless)
+      let (index, offsets, tagless, niche) ← match layoutMap[global]? with
+        | some (.function layout) => pure (layout.index, layout.offsets, false, none)
+        | some (.constructor layout) =>
+          pure (layout.index, layout.offsets, layout.tagless, layout.niche)
         | _ => throw s!"addCase: layout missing for `{global}`"
       -- Bind each sub-pattern `Local` to the corresponding slice of `idxs`.
       -- A tagged layout reserves `idxs[0]` for the tag, so argument `i` occupies
       -- `idxs[1 + offsets[i] .. 1 + offsets[i+1]]`. A tagless (single-variant)
       -- layout has no tag slot, so the base is `0` — a tuple-identical layout.
-      let base := if tagless then 0 else 1
+      let base := if tagless || niche.isSome then 0 else 1
       let ptrBindings : Std.HashMap Local (Array Bytecode.ValIdx) :=
         (Array.range pats.size).foldl (init := bindings) fun acc i =>
           let startOff := base + (offsets[i]?.getD 0)
@@ -570,13 +722,40 @@ def Concrete.addCase
       -- Single-variant: emit the arm as the unconditional default. With no other
       -- cases the `.match`/`.matchContinue` always falls through to it, so no tag
       -- discrimination occurs (`idxs[0]` is a field, never a tag).
+      -- Niche: the match dispatches on the pointer slot — the nullary
+      -- constructor is case 0 (the impossible-pointer value), the payload
+      -- constructor is the default arm (its pointer is provably nonzero,
+      -- so the default arm's inequality witness against 0 always exists).
       if tagless then pure (cases, .some term)
-      else pure (cases.push (.ofNat index, term), defaultBlock)
+      else match niche with
+        | some _ =>
+          if pats.isEmpty then pure (cases.push (0, term), defaultBlock)
+          else pure (cases, .some term)
+        | none => pure (cases.push (.ofNat index, term), defaultBlock)
     | .wildcard => do
-      let initState ← get
-      let term ← term.compile returnTyp layoutMap bindings yieldCtrl
-      set { initState with selIdx := (← get).selIdx }
-      pure (cases, .some term)
+      -- In a niche match with a payload arm, the wildcard covers only the
+      -- nullary constructor: it becomes case 0 (or is dead if the nullary
+      -- arm is also listed, and is then NOT compiled — a discarded compile
+      -- would still consume a selector index). Otherwise it is the default.
+      match Concrete.nicheMatchCtx layoutMap allCases with
+      | some ctx =>
+        if ctx.hasPayload then
+          if ctx.hasNullary then pure (cases, defaultBlock)
+          else do
+            let initState ← get
+            let term ← term.compile returnTyp layoutMap bindings yieldCtrl
+            set { initState with selIdx := (← get).selIdx }
+            pure (cases.push (0, term), defaultBlock)
+        else do
+          let initState ← get
+          let term ← term.compile returnTyp layoutMap bindings yieldCtrl
+          set { initState with selIdx := (← get).selIdx }
+          pure (cases, .some term)
+      | none => do
+        let initState ← get
+        let term ← term.compile returnTyp layoutMap bindings yieldCtrl
+        set { initState with selIdx := (← get).selIdx }
+        pure (cases, .some term)
     | _ => throw "addCase: unsupported pattern in concrete lower"
 termination_by _ pair => (sizeOf pair.snd, 1)
 decreasing_by all_goals first | decreasing_tactic | grind
diff --git a/Ix/Aiur/Interpret.lean b/Ix/Aiur/Interpret.lean
index ff5625ac..73722ccc 100644
--- a/Ix/Aiur/Interpret.lean
+++ b/Ix/Aiur/Interpret.lean
@@ -65,7 +65,7 @@ partial def Value.ppDeref (store : Store) (depth : Nat) : Value → String
   | .pointer _ n =>
       if depth == 0 then "..."
       else
-        match store.getByIdx n with
+        match (if n == 0 then none else store.getByIdx (n - 1)) with
         | some (vs, _) =>
             -- Stored value is `Array Value`; for tagged enums it's
             -- typically `[ctor]` or `[tag, fields...]`. Recurse on each.
@@ -92,7 +92,7 @@ private def matchPattern (store : Store) :
   | .or p1 p2,    v           =>
       matchPattern store p1 v <|> matchPattern store p2 v
   | .pointer p,   .pointer _ n =>
-      match store.getByIdx n with
+      match (if n == 0 then none else store.getByIdx (n - 1)) with
       | some (vs, _) => vs[0]?.bind (matchPattern store p ·)
       | none         => none
   | _,            _           => none
@@ -204,40 +204,41 @@ private def callSite (g : Global) (args : List Value) (m : InterpM Value) : Inte
 
 Value-level mirror of `read_klimbs_u64` / `build_klimbs_u64` in
 `crates/aiur/src/execute.rs`; see `Ix/Aiur/Semantics/SourceEval.lean` for
-the reference-evaluator twin. Constructor 0 = Cons(limb, rest),
-constructor 1 = Nil; limb bytes little-endian, limbs head-first. -/
+the reference-evaluator twin. The list is the niche enum
+`{ Nil, Cons(&(limb, tail)) }`: Nil is a bare value (nothing stored), Cons
+carries a pointer to the `(limb, tail)` cell. Limb bytes little-endian,
+limbs head-first. -/
 
 /-- Store a value content-deduped, returning its pointer (the `.store`
 semantics, callable from the divmod chain builder). -/
 private def storeValueI (v : Value) : InterpM Value := do
   let store ← getStore
   if let some idx := store.getIdxOf #[v] then
-    return .pointer 0 idx
+    return .pointer 0 (idx + 1)
   let idx := store.size
   modify fun s => { s with store := s.store.insert #[v] () }
-  return .pointer 0 idx
+  return .pointer 0 (idx + 1)
 
 /-- Walk a limb-chain pointer, returning the node datatype and the limbs
 head-first. `steps` bounds the walk so a malformed cycle terminates. -/
 private def readLimbChainI (decls : Decls) :
     Nat → Value → InterpM (DataType × List (Array G))
   | 0, _ => throwErr "unconstrainedBigUintDivMod: cyclic limb list"
-  | steps+1, ptrVal => do
-    match ptrVal with
-    | .pointer _ n =>
-      let store ← getStore
-      match store.getByIdx n with
-      | none => throwErr s!"unconstrainedBigUintDivMod: invalid pointer {n}"
-      | some (vs, _) =>
-        match (vs[0]? : Option Value) with
-        | some (.ctor g args) =>
-          match decls.getByKey g with
-          | some (.constructor dt ctor) =>
-            let tag := dt.constructors.findIdx? (· == ctor) |>.getD 0
-            if tag == 1 then pure (dt, [])
-            else if tag == 0 then
-              match args with
-              | #[.array byteVals, rest] =>
+  | steps+1, listVal => do
+    match listVal with
+    | .ctor g args =>
+      match decls.getByKey g with
+      | some (.constructor dt _) =>
+        if args.isEmpty then pure (dt, [])  -- Nil: no cell exists
+        else
+          match args with
+          | #[.pointer _ n] =>
+            let store ← getStore
+            match (if n == 0 then none else store.getByIdx (n - 1)) with
+            | none => throwErr s!"unconstrainedBigUintDivMod: invalid pointer {n}"
+            | some (vs, _) =>
+              match (vs[0]? : Option Value) with
+              | some (.tuple #[.array byteVals, rest]) =>
                 let bytes ← byteVals.mapM fun bv =>
                   match bv with
                   | .field b =>
@@ -250,21 +251,20 @@ private def readLimbChainI (decls : Decls) :
                   let (_, restLimbs) ← readLimbChainI decls steps rest
                   pure (dt, bytes :: restLimbs)
                 else throwErr "unconstrainedBigUintDivMod: limb is not [U8; 8]"
-              | _ => throwErr "unconstrainedBigUintDivMod: malformed Cons node"
-            else
-              throwErr "unconstrainedBigUintDivMod: unexpected constructor tag"
-          | _ => throwErr s!"unconstrainedBigUintDivMod: unbound ctor {g}"
-        | _ => throwErr "unconstrainedBigUintDivMod: node is not a constructor"
-    | _ => throwErr "unconstrainedBigUintDivMod: input is not a pointer"
+              | _ => throwErr "unconstrainedBigUintDivMod: malformed Cons cell"
+          | _ => throwErr "unconstrainedBigUintDivMod: malformed Cons value"
+      | _ => throwErr s!"unconstrainedBigUintDivMod: unbound ctor {g}"
+    | _ => throwErr "unconstrainedBigUintDivMod: input is not a list value"
 
 /-- Build a limb chain from head-first `limbs` (Nil first, limbs in
 reverse — same allocation order as the Rust builder). -/
 private def buildLimbChainI (consG nilG : Global) :
     List (Array G) → InterpM Value
-  | [] => storeValueI (.ctor nilG #[])
+  | [] => pure (.ctor nilG #[])  -- Nil IS the value; nothing is stored
   | limb :: rest => do
-    let restPtr ← buildLimbChainI consG nilG rest
-    storeValueI (.ctor consG #[.array (limb.map .field), restPtr])
+    let restVal ← buildLimbChainI consG nilG rest
+    let cellPtr ← storeValueI (.tuple #[.array (limb.map .field), restVal])
+    pure (.ctor consG #[cellPtr])
 
 mutual
 
@@ -368,15 +368,15 @@ partial def interp (decls : Decls) (bindings : Bindings) : Term → InterpM Valu
       let v ← interp decls bindings t
       let store ← getStore
       if let some idx := store.getIdxOf #[v] then
-        return .pointer 0 idx
+        return .pointer 0 (idx + 1)
       let idx := store.size
       modify fun s => { s with store := s.store.insert #[v] () }
-      return .pointer 0 idx
+      return .pointer 0 (idx + 1)
   | .load t => do
       match ← interp decls bindings t with
       | .pointer _ n =>
           let store ← getStore
-          match store.getByIdx n with
+          match (if n == 0 then none else store.getByIdx (n - 1)) with
           | some (vs, _) => return vs[0]!
           | none         => throwErr s!"load: invalid pointer {n}"
       | _ => throwErr "load: expected pointer"
@@ -481,7 +481,9 @@ partial def interp (decls : Decls) (bindings : Bindings) : Term → InterpM Valu
       let bound := (← getStore).size + 1
       let (dt, aLimbs) ← readLimbChainI decls bound aPtr
       let (_, bLimbs) ← readLimbChainI decls bound bPtr
-      match dt.constructors[0]?, dt.constructors[1]? with
+      -- Identify Cons/Nil by shape (nullary = Nil), not declaration order.
+      match dt.constructors.find? (!·.argTypes.isEmpty),
+            dt.constructors.find? (·.argTypes.isEmpty) with
       | some cons, some nil =>
         let consG := dt.name.pushNamespace cons.nameHead
         let nilG := dt.name.pushNamespace nil.nameHead
diff --git a/Ix/Aiur/Semantics/BytecodeEval.lean b/Ix/Aiur/Semantics/BytecodeEval.lean
index 72e11a03..9be25ca4 100644
--- a/Ix/Aiur/Semantics/BytecodeEval.lean
+++ b/Ix/Aiur/Semantics/BytecodeEval.lean
@@ -82,64 +82,68 @@ def readIdxs (st : EvalState) (vs : Array ValIdx) : Except BytecodeError (Array
 
 /-! ## Memory ops -/
 
-/-- Insert/retrieve at a specific width bucket; returns the insertion index. -/
+/-- Insert/retrieve at a specific width bucket; returns the 1-BASED pointer
+(insertion index + 1). Pointer 0 is reserved as the impossible (null)
+pointer — the memory circuit pins the first row's pointer to 1, so no
+valid store ever answers to 0 (mirrors `execute.rs`). -/
 def memStore (st : EvalState) (vals : Array G) : EvalState × Nat :=
   let width := vals.size
   let bucket := st.memory.getByKey width |>.getD default
   if let some idx := bucket.getIdxOf vals then
-    (st, idx)
+    (st, idx + 1)
   else
     let idx := bucket.size
     let newBucket := bucket.insert vals ()
     let newMem := st.memory.insert width newBucket
-    ({ st with memory := newMem }, idx)
+    ({ st with memory := newMem }, idx + 1)
 
-/-- Load from the width-`size` bucket at index `ptr`. -/
+/-- Load from the width-`size` bucket at 1-based pointer `ptr`; 0 is the
+reserved null pointer and never binds. -/
 def memLoad (st : EvalState) (size : Nat) (ptr : Nat) :
     Except BytecodeError (Array G) :=
-  match st.memory.getByKey size with
-  | none        => .error (.invalidPointer size ptr)
-  | some bucket =>
-    match bucket.getByIdx ptr with
+  match st.memory.getByKey size, ptr with
+  | none, _ | _, 0 => .error (.invalidPointer size ptr)
+  | some bucket, idx + 1 =>
+    match bucket.getByIdx idx with
     | some (vs, _) => .ok vs
     | none         => .error (.invalidPointer size ptr)
 
 /-! ## `List<U64>` limb chains (`unconstrainedBigUintDivMod`)
 
 Mirrors `read_klimbs_u64` / `build_klimbs_u64` in `crates/aiur/src/execute.rs`:
-nodes live in the width-10 memory bucket with the standard tagged-enum
-layout `[tag, byte0..byte7, next_ptr]` — tag 0 = Cons, tag 1 = Nil, bytes
-little-endian within the u64 limb. -/
+`List<U64>` is the niche enum `{ Nil, Cons(&(U64, List<U64>)) }` — the list
+value is one field element, 0 = Nil (no node stored), otherwise a pointer
+to the `(limb, tail)` cell in the width-9 bucket, `[byte0..byte7, tail]`.
+Bytes are little-endian within the u64 limb. -/
 
 /-- Walk a limb chain from `ptr`, returning the limbs head-first. `steps`
-bounds the walk: a chain longer than the width-10 bucket must revisit a
+bounds the walk: a chain longer than the width-9 bucket must revisit a
 pointer, i.e. a malformed cycle. -/
 def readLimbChain (st : EvalState) : Nat → Nat →
     Except BytecodeError (List (Array G))
   | 0, _ => .error .unconstrainedBigUintDivModFailed
   | steps+1, ptr => do
-    let vs ← memLoad st 10 ptr
-    match vs[0]?, vs[9]? with
-    | some tag, some next =>
-      if tag == 1 then pure []
-      else if tag == 0 then
-        let bytes := vs.extract 1 9
+    if ptr == 0 then pure []  -- Nil IS the zero list value; no node exists
+    else
+      let vs ← memLoad st 9 ptr
+      match vs[8]? with
+      | some next =>
+        let bytes := vs.extract 0 8
         if bytes.size == 8 && bytes.all (·.val < 256) then do
           let rest ← readLimbChain st steps next.val.toNat
           pure (bytes :: rest)
         else .error .unconstrainedBigUintDivModFailed
-      else .error .unconstrainedBigUintDivModFailed
-    | _, _ => .error .unconstrainedBigUintDivModFailed
+      | _ => .error .unconstrainedBigUintDivModFailed
 
 /-- Build a limb chain from head-first `limbs`, returning the head pointer.
 Same insertion order as the Rust builder (Nil first, then limbs in reverse),
 so freshly-created pointer indices agree; `memStore` content-dedups like
 `QueryMap` does. -/
 def buildLimbChain (st : EvalState) : List (Array G) → EvalState × Nat
-  | [] => memStore st (#[1] ++ Array.replicate 9 0)
+  | [] => (st, 0)  -- Nil IS the zero list value; nothing is stored
   | limb :: rest =>
     let (st', restPtr) := buildLimbChain st rest
-    memStore st' (#[0] ++ limb ++ #[.ofNat restPtr])
+    memStore st' (limb ++ #[.ofNat restPtr])
 
 def pushMap (st : EvalState) (g : G) : EvalState :=
   { st with map := st.map.push g }
@@ -350,7 +354,7 @@ def evalOp (t : Bytecode.Toplevel) (fuel : Nat) (op : Op) (st : EvalState) :
   | .unconstrainedBigUintDivMod a b => do
     let aPtr ← readIdx st a
     let bPtr ← readIdx st b
-    -- Walk bound: the width-10 bucket size plus one (see `readLimbChain`).
+    -- Walk bound: the width-9 bucket size plus one (see `readLimbChain`).
     let bound := (st.memory.getByKey 10 |>.map (·.size) |>.getD 0) + 1
     let aLimbs ← readLimbChain st bound aPtr.val.toNat
     let bLimbs ← readLimbChain st bound bPtr.val.toNat
diff --git a/Ix/Aiur/Semantics/Flatten.lean b/Ix/Aiur/Semantics/Flatten.lean
index 81c64391..def809a6 100644
--- a/Ix/Aiur/Semantics/Flatten.lean
+++ b/Ix/Aiur/Semantics/Flatten.lean
@@ -149,16 +149,32 @@ def typFlatSizeBound (decls : Source.Decls) : Nat → HashSet Global → Typ →
         | _ => 0
   | _+1, _, .mvar _ => 0
 
+/-- Null-pointer niche at the `Source` level (mirror of
+`Concrete.DataType.hasPointerNiche`): exactly two constructors, one
+nullary, the other with a top-level pointer field. Pointers are 1-based,
+so the pointer slot doubles as the discriminant (0 = the nullary variant)
+and the tag slot is dropped. -/
+def dataTypeHasPointerNiche (dt : DataType) : Bool :=
+  let isPtr : Typ → Bool := fun | .pointer _ => true | _ => false
+  match dt.constructors with
+  | [a, b] =>
+    (a.argTypes.isEmpty && b.argTypes.any isPtr) ||
+    (b.argTypes.isEmpty && a.argTypes.any isPtr)
+  | _ => false
+
 /-- Flat size of a datatype (max constructor size + 1 for the tag; the `+ 1`
-is dropped for single-variant enums, which carry no tag). -/
+is dropped for single-variant enums, which carry no tag, and for
+null-pointer-niche enums, whose pointer field doubles as the tag). -/
 def dataTypeFlatSizeBound (decls : Source.Decls) : Nat → HashSet Global → DataType → Nat
   | 0, _, _ => 1
   | bound+1, visited, dt =>
       let ctorSizes := dt.constructors.map fun ctor =>
         ctor.argTypes.foldl (init := 0)
           (fun acc t => acc + typFlatSizeBound decls bound visited t)
-      -- Single-variant enums carry no tag slot (tuple-identical layout).
-      if dt.constructors.length == 1 then ctorSizes.foldl max 0
+      -- Single-variant enums carry no tag slot (tuple-identical layout);
+      -- neither do null-pointer-niche enums.
+      if dt.constructors.length == 1 || dataTypeHasPointerNiche dt then
+        ctorSizes.foldl max 0
       else ctorSizes.foldl max 0 + 1
 
 end
@@ -200,8 +216,13 @@ def flattenValue (decls : Decls) (funcIdx : Global → Option Nat) :
           let dtSize := dataTypeFlatSize decls {} dt
           let argsFlat := args.attach.flatMap (fun ⟨v, _⟩ => flattenValue decls funcIdx v)
           -- Single-variant enums carry no tag slot (tuple-identical layout).
+          -- Null-pointer-niche enums drop the tag too: the nullary
+          -- constructor flattens to all zeros (its args are empty, so
+          -- `argsFlat` is empty and padding fills the width), the payload
+          -- constructor to its bare fields.
           let flat :=
-            if dt.constructors.length == 1 then argsFlat
+            if dt.constructors.length == 1 || dataTypeHasPointerNiche dt then
+              argsFlat
             else
               let ctorIndex := dt.constructors.findIdx? (· == ctor) |>.getD 0
               #[.ofNat ctorIndex] ++ argsFlat
@@ -311,16 +332,41 @@ def unflattenValueBound (decls : Source.Decls) (gs : Array G) :
       match decls.getByKey g with
       | some (.dataType dt) =>
           let dtSize := dataTypeFlatSize decls {} dt
-          let tag := (gs.getD offset 0).val.toNat
           let ctors := dt.constructors.toArray
-          if h : tag < ctors.size then
-            let ctor := ctors[tag]
+          -- Untagged layouts: single-variant enums parse the sole
+          -- constructor's fields from offset 0; null-pointer-niche enums
+          -- dispatch on the niche pointer slot (0 = the nullary variant).
+          let parseCtor (ctor : Constructor) (fieldsBase : Nat) : Value :=
             let ctorName := dt.name.pushNamespace ctor.nameHead
-            let (args, _) := ctor.argTypes.foldl (init := (#[], 1)) fun (acc, off) t =>
-              let (v, n) := unflattenValueBound decls gs bound (offset + off) t
-              (acc.push v, off + n)
-            (.ctor ctorName args, dtSize)
-          else (.field (gs.getD offset 0), dtSize)
+            let (args, _) := ctor.argTypes.foldl (init := (#[], fieldsBase))
+              fun (acc, off) t =>
+                let (v, n) := unflattenValueBound decls gs bound (offset + off) t
+                (acc.push v, off + n)
+            .ctor ctorName args
+          if h : ctors.size = 1 then
+            (parseCtor ctors[0] 0, dtSize)
+          else if dataTypeHasPointerNiche dt then
+            let nullary := ctors.find? (·.argTypes.isEmpty)
+            let payload := ctors.find? (!·.argTypes.isEmpty)
+            match nullary, payload with
+            | some nullary, some payload =>
+              -- The niche slot is the payload's first pointer field; its
+              -- offset is the size of the preceding fields.
+              let slot := (payload.argTypes.foldl (init := (0, false))
+                fun (off, found) t =>
+                  if found then (off, found)
+                  else match t with
+                    | .pointer _ => (off, true)
+                    | _ => (off + typFlatSize decls {} t, false)).1
+              if (gs.getD (offset + slot) 0) == 0 then
+                (.ctor (dt.name.pushNamespace nullary.nameHead) #[], dtSize)
+              else (parseCtor payload 0, dtSize)
+            | _, _ => (.field (gs.getD offset 0), dtSize)
+          else
+            let tag := (gs.getD offset 0).val.toNat
+            if h : tag < ctors.size then
+              (parseCtor ctors[tag] 1, dtSize)
+            else (.field (gs.getD offset 0), dtSize)
       | _ => (.field (gs.getD offset 0), 1)
   | _+1, _, .mvar _ => (.unit, 0)
 termination_by bound _ _ => bound
diff --git a/Ix/Aiur/Semantics/SourceEval.lean b/Ix/Aiur/Semantics/SourceEval.lean
index 7a60b6ef..df29eac1 100644
--- a/Ix/Aiur/Semantics/SourceEval.lean
+++ b/Ix/Aiur/Semantics/SourceEval.lean
@@ -92,12 +92,12 @@ def matchPattern (store : Store) :
   | .or p1 p2,    v           =>
       matchPattern store p1 v <|> matchPattern store p2 v
   | .pointer p,   .pointer w n =>
-      match store[w]? with
-      | some inner =>
-        match inner.getByIdx n with
+      match store[w]?, n with
+      | some inner, idx + 1 =>
+        match inner.getByIdx idx with
         | some (vs, _) => vs[0]?.bind (matchPattern store p ·)
         | none         => none
-      | none => none
+      | _, _ => none
   | _,            _           => none
 
 def matchPatsList (store : Store) :
@@ -139,23 +139,25 @@ def storeValue (decls : Decls) (st : EvalState) (v : Value) : Value × EvalState
   let w := (flattenValue decls (fun _ => none) v).size
   let inner := st.store[w]?.getD (default : IndexMap (Array Value) Unit)
   if let some idx := inner.getIdxOf #[v] then
-    (.pointer w idx, st)
+    (.pointer w (idx + 1), st)
   else
     let idx := inner.size
     let inner' := inner.insert #[v] ()
-    (.pointer w idx, { st with store := st.store.insert w inner' })
+    (.pointer w (idx + 1), { st with store := st.store.insert w inner' })
 
-/-- Dereference a `(width, index)` pointer. -/
+/-- Dereference a `(width, 1-based index)` pointer; 0 is the reserved null
+pointer and never binds (mirrors the executor and the memory circuit's
+first-row pin). -/
 def loadValue (st : EvalState) (w n : Nat) : Except SourceError Value :=
-  match st.store[w]? with
-  | some inner =>
-    match inner.getByIdx n with
+  match st.store[w]?, n with
+  | none, _ | _, 0 => .error (.invalidPointer n)
+  | some inner, idx + 1 =>
+    match inner.getByIdx idx with
     | some (vs, _) =>
       match vs[0]? with
       | some v => .ok v
       | none   => .error (.invalidPointer n)
     | none => .error (.invalidPointer n)
-  | none => .error (.invalidPointer n)
 
 /-! ### `List<U64>` limb chains (`unconstrainedBigUintDivMod`)
 
@@ -178,16 +180,17 @@ must revisit a pointer, i.e. a malformed cycle). -/
 def readLimbChain (decls : Decls) (st : EvalState) :
     Nat → Value → Except SourceError (DataType × List (Array G))
   | 0, _ => .error (.typeMismatch "unconstrainedBigUintDivMod: cyclic limb list")
-  | steps+1, ptrVal => do
-    match ptrVal with
-    | .pointer w n =>
-      match ← loadValue st w n with
-      | .ctor g args =>
-        let (dt, tag) ← ctorInfo decls g
-        if tag == 1 then pure (dt, [])
-        else if tag == 0 then
-          match args with
-          | #[.array byteVals, rest] =>
+  | steps+1, listVal => do
+    match listVal with
+    | .ctor g args =>
+      let (dt, _) ← ctorInfo decls g
+      if args.isEmpty then pure (dt, [])  -- Nil: no cell exists
+      else
+        match args with
+        | #[.pointer w n] =>
+          -- Cons carries a pointer to the `(limb, tail)` cell.
+          match ← loadValue st w n with
+          | .tuple #[.array byteVals, rest] =>
             let bytes ← byteVals.mapM fun bv =>
               match bv with
               | .field b =>
@@ -202,23 +205,23 @@ def readLimbChain (decls : Decls) (st : EvalState) :
             else throw (.typeMismatch
               "unconstrainedBigUintDivMod: limb is not [U8; 8]")
           | _ => throw (.typeMismatch
-              "unconstrainedBigUintDivMod: malformed Cons node")
-        else throw (.typeMismatch
-          "unconstrainedBigUintDivMod: unexpected constructor tag")
-      | _ => throw (.typeMismatch
-          "unconstrainedBigUintDivMod: node is not a constructor")
+              "unconstrainedBigUintDivMod: malformed Cons cell")
+        | _ => throw (.typeMismatch
+            "unconstrainedBigUintDivMod: malformed Cons value")
     | _ => throw (.typeMismatch
-        "unconstrainedBigUintDivMod: input is not a pointer")
+        "unconstrainedBigUintDivMod: input is not a list value")
 
 /-- Build a limb chain from head-first `limbs` using the given Cons/Nil
 constructor names; returns the head pointer value. Same order as the Rust
 builder (Nil first, then limbs in reverse). -/
 def buildLimbChain (decls : Decls) (consG nilG : Global) (st : EvalState) :
     List (Array G) → Value × EvalState
-  | [] => storeValue decls st (.ctor nilG #[])
+  | [] => (.ctor nilG #[], st)  -- Nil IS the value; nothing is stored
   | limb :: rest =>
-    let (restPtr, st') := buildLimbChain decls consG nilG st rest
-    storeValue decls st' (.ctor consG #[.array (limb.map .field), restPtr])
+    let (restVal, st') := buildLimbChain decls consG nilG st rest
+    let (cellPtr, st'') := storeValue decls st'
+      (.tuple #[.array (limb.map .field), restVal])
+    (.ctor consG #[cellPtr], st'')
 
 /-- Semantic model of `unconstrainedBigUintDivMod` on already-evaluated
 pointer values: walk both chains, divide as `Nat` (which matches the
@@ -229,7 +232,9 @@ def bigUintDivModValue (decls : Decls) (aPtr bPtr : Value)
   let bound := st.store.fold (init := 1) fun acc _ inner => acc + inner.size
   let (dt, aLimbs) ← readLimbChain decls st bound aPtr
   let (_, bLimbs) ← readLimbChain decls st bound bPtr
-  match dt.constructors[0]?, dt.constructors[1]? with
+  -- Identify Cons/Nil by shape (nullary = Nil), not by declaration order.
+  match dt.constructors.find? (!·.argTypes.isEmpty),
+        dt.constructors.find? (·.argTypes.isEmpty) with
   | some cons, some nil =>
     let consG := dt.name.pushNamespace cons.nameHead
     let nilG := dt.name.pushNamespace nil.nameHead
diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean
index 5fdf8fde..29a3d9f4 100644
--- a/Ix/Aiur/Stages/Codegen.lean
+++ b/Ix/Aiur/Stages/Codegen.lean
@@ -33,7 +33,8 @@
     `!unconstrained && !op_unconstrained` for `Op::Call`, and
     `!unconstrained` for `Op::Store` / `Op::Load`.
   - `memory_queries[size]` insertion order: each unique store gets a
-    pointer = `memory_queries.len()` at that moment.
+    pointer = `memory_queries.len() + 1` at that moment (1-based;
+    0 is the reserved null pointer).
   - `bytes1_queries` / `bytes2_queries` updates from `U8*` ops in
     constrained mode, suppressed when `unconstrained == true`.
   - `io_buffer` ops preserve order.
@@ -418,7 +419,7 @@ private def emitStore (out : Nat) (values : Array ValIdx) : Array RustStmt :=
     s!" if !unconstrained \{ *result.multiplicity += G::ONE; }" ++
     s!" result.output[0]" ++
     s!" } else \{" ++
-    s!" let __ptr = G::from_usize(__mq.len());" ++
+    s!" let __ptr = G::from_usize(__mq.len() + 1);" ++
     s!" __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }"
   #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)]
 
@@ -429,7 +430,7 @@ private def emitLoad (out : Nat) (size : Nat) (ptr : ValIdx) : Array RustStmt :=
     s!"\{ let __mq = record.memory_queries.get_mut(&{size}).ok_or(ExecError::InvalidMemorySize({size}))?;" ++
     s!" let __ptr_u64 = __v_{ptr}.as_canonical_u64();" ++
     s!" let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?;" ++
-    s!" let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer \{ ptr: __ptr_u64, size: {size} })?;" ++
+    s!" let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer \{ ptr: __ptr_u64, size: {size} })?;" ++
     s!" if !unconstrained \{ *__mult += G::ONE; }" ++
     s!" let __arr: [G; {size}] = __args[..{size}].try_into().unwrap(); __arr }"
   let mut stmts : Array RustStmt := #[
diff --git a/Ix/IxVM/Blake3.lean b/Ix/IxVM/Blake3.lean
index 014bded1..b5a064ce 100644
--- a/Ix/IxVM/Blake3.lean
+++ b/Ix/IxVM/Blake3.lean
@@ -30,9 +30,12 @@ def blake3 := ⟦
 
   /- # Implementation -/
 
+  -- Null-pointer-niche chunk-tree layer, mimicking `List`: a `Layer`
+  -- value is ONE field element — 0 is Nil, anything else points at the
+  -- `(previous layer, digest)` cell.
   enum Layer {
-    Push(&Layer, [[U8; 4]; 8]),
-    Nil
+    Nil,
+    Push(&(Layer, [[U8; 4]; 8]))
   }
 
   enum MaybeDigest {
@@ -42,7 +45,7 @@ def blake3 := ⟦
 
   fn blake3(input: ByteStream) -> [[U8; 4]; 8] {
     let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
-    blake3_compress_layer(load(blake3_compress_chunks(input, store(ListNode.Nil), 0, 0, store([0u8; 8]), store(IV), store(Layer.Nil))))
+    blake3_compress_layer(blake3_compress_chunks(input, List.Nil, 0, 0, store([0u8; 8]), store(IV), Layer.Nil))
   }
 
   -- Hash `bytes` and assert the digest equals `expected`. Used by every
@@ -82,8 +85,9 @@ def blake3 := ⟦
   fn blake3_next_layer(layer: Layer, digest: [[U8; 4]; 8], root: G) -> (MaybeDigest, Layer) {
     match layer {
       Layer.Nil => (MaybeDigest.Some(digest), Layer.Nil),
-      Layer.Push(layer, other) =>
-        let (last, new_layer) = blake3_next_layer(load(layer), other, 0);
+      Layer.Push(__lp) =>
+        let (layer, other) = load(__lp);
+        let (last, new_layer) = blake3_next_layer(layer, other, 0);
         match last {
           MaybeDigest.None => (MaybeDigest.Some(digest), new_layer),
           MaybeDigest.Some(last) =>
@@ -97,25 +101,26 @@ def blake3 := ⟦
               Layer.Nil =>
                 let flags = PARENT + ROOT * root;
                 let digest = blake3_compress(IV, blocks, [0u8; 8], 64, flags);
-                (MaybeDigest.None, Layer.Push(store(new_layer), digest)),
+                (MaybeDigest.None, Layer.Push(store((new_layer, digest)))),
               _ =>
                 let flags = PARENT;
                 let digest = blake3_compress(IV, blocks, [0u8; 8], 64, flags);
-                (MaybeDigest.None, Layer.Push(store(new_layer), digest)),
+                (MaybeDigest.None, Layer.Push(store((new_layer, digest)))),
             },
         },
     }
   }
 
   fn blake3_compress_layer(layer: Layer) -> [[U8; 4]; 8] {
-    let Layer.Push(rest, digest) = layer;
-    match load(rest) {
+    let Layer.Push(__lc) = layer;
+    let (rest, digest) = load(__lc);
+    match rest {
       Layer.Nil => digest,
       rest =>
         let (last, new_merkle) = blake3_next_layer(rest, digest, 1);
         match last {
           MaybeDigest.None => blake3_compress_layer(new_merkle),
-          MaybeDigest.Some(last) => blake3_compress_layer(Layer.Push(store(new_merkle), last)),
+          MaybeDigest.Some(last) => blake3_compress_layer(Layer.Push(store((new_merkle, last)))),
         },
     }
   }
@@ -131,14 +136,14 @@ def blake3 := ⟦
     chunk_index: G,
     chunk_count: &U64,
     block_digest: &[[U8; 4]; 8],
-    layer: &Layer
-  ) -> &Layer {
-    match load(input) {
+    layer: Layer
+  ) -> Layer {
+    match input {
       -- Input exhausted: hand off to the cold finalize circuit.
-      ListNode.Nil =>
+      List.Nil =>
         blake3_finish(byte_acc, block_index, chunk_index, chunk_count, block_digest, layer),
-      ListNode.Cons(head, input) =>
-        let byte_acc = store(ListNode.Cons(head, byte_acc));
+      List.Cons(__cell1) => let (head, input) = load(__cell1);
+        let byte_acc = List.Cons(store((head, byte_acc)));
         match block_index {
           63 => blake3_compress_block(input, byte_acc, chunk_index, chunk_count, block_digest, layer),
           _ => blake3_compress_chunks(input, byte_acc, block_index + 1, chunk_index + 1, chunk_count, block_digest, layer),
@@ -151,70 +156,70 @@ def blake3 := ⟦
   -- 64 unrolled `load`s, one circuit row per call — keeps the 64-wide buffer
   -- out of the hot loop and out of `inputSize`.
   fn bytes_to_block(byte_acc: ByteStream) -> [[U8; 4]; 16] {
-    let ListNode.Cons(b63, l) = load(byte_acc);
-    let ListNode.Cons(b62, l) = load(l);
-    let ListNode.Cons(b61, l) = load(l);
-    let ListNode.Cons(b60, l) = load(l);
-    let ListNode.Cons(b59, l) = load(l);
-    let ListNode.Cons(b58, l) = load(l);
-    let ListNode.Cons(b57, l) = load(l);
-    let ListNode.Cons(b56, l) = load(l);
-    let ListNode.Cons(b55, l) = load(l);
-    let ListNode.Cons(b54, l) = load(l);
-    let ListNode.Cons(b53, l) = load(l);
-    let ListNode.Cons(b52, l) = load(l);
-    let ListNode.Cons(b51, l) = load(l);
-    let ListNode.Cons(b50, l) = load(l);
-    let ListNode.Cons(b49, l) = load(l);
-    let ListNode.Cons(b48, l) = load(l);
-    let ListNode.Cons(b47, l) = load(l);
-    let ListNode.Cons(b46, l) = load(l);
-    let ListNode.Cons(b45, l) = load(l);
-    let ListNode.Cons(b44, l) = load(l);
-    let ListNode.Cons(b43, l) = load(l);
-    let ListNode.Cons(b42, l) = load(l);
-    let ListNode.Cons(b41, l) = load(l);
-    let ListNode.Cons(b40, l) = load(l);
-    let ListNode.Cons(b39, l) = load(l);
-    let ListNode.Cons(b38, l) = load(l);
-    let ListNode.Cons(b37, l) = load(l);
-    let ListNode.Cons(b36, l) = load(l);
-    let ListNode.Cons(b35, l) = load(l);
-    let ListNode.Cons(b34, l) = load(l);
-    let ListNode.Cons(b33, l) = load(l);
-    let ListNode.Cons(b32, l) = load(l);
-    let ListNode.Cons(b31, l) = load(l);
-    let ListNode.Cons(b30, l) = load(l);
-    let ListNode.Cons(b29, l) = load(l);
-    let ListNode.Cons(b28, l) = load(l);
-    let ListNode.Cons(b27, l) = load(l);
-    let ListNode.Cons(b26, l) = load(l);
-    let ListNode.Cons(b25, l) = load(l);
-    let ListNode.Cons(b24, l) = load(l);
-    let ListNode.Cons(b23, l) = load(l);
-    let ListNode.Cons(b22, l) = load(l);
-    let ListNode.Cons(b21, l) = load(l);
-    let ListNode.Cons(b20, l) = load(l);
-    let ListNode.Cons(b19, l) = load(l);
-    let ListNode.Cons(b18, l) = load(l);
-    let ListNode.Cons(b17, l) = load(l);
-    let ListNode.Cons(b16, l) = load(l);
-    let ListNode.Cons(b15, l) = load(l);
-    let ListNode.Cons(b14, l) = load(l);
-    let ListNode.Cons(b13, l) = load(l);
-    let ListNode.Cons(b12, l) = load(l);
-    let ListNode.Cons(b11, l) = load(l);
-    let ListNode.Cons(b10, l) = load(l);
-    let ListNode.Cons(b9, l) = load(l);
-    let ListNode.Cons(b8, l) = load(l);
-    let ListNode.Cons(b7, l) = load(l);
-    let ListNode.Cons(b6, l) = load(l);
-    let ListNode.Cons(b5, l) = load(l);
-    let ListNode.Cons(b4, l) = load(l);
-    let ListNode.Cons(b3, l) = load(l);
-    let ListNode.Cons(b2, l) = load(l);
-    let ListNode.Cons(b1, l) = load(l);
-    let ListNode.Cons(b0, _) = load(l);
+    let List.Cons(__lcell1001) = byte_acc; let (b63, l) = load(__lcell1001);
+    let List.Cons(__lcell1002) = l; let (b62, l) = load(__lcell1002);
+    let List.Cons(__lcell1003) = l; let (b61, l) = load(__lcell1003);
+    let List.Cons(__lcell1004) = l; let (b60, l) = load(__lcell1004);
+    let List.Cons(__lcell1005) = l; let (b59, l) = load(__lcell1005);
+    let List.Cons(__lcell1006) = l; let (b58, l) = load(__lcell1006);
+    let List.Cons(__lcell1007) = l; let (b57, l) = load(__lcell1007);
+    let List.Cons(__lcell1008) = l; let (b56, l) = load(__lcell1008);
+    let List.Cons(__lcell1009) = l; let (b55, l) = load(__lcell1009);
+    let List.Cons(__lcell1010) = l; let (b54, l) = load(__lcell1010);
+    let List.Cons(__lcell1011) = l; let (b53, l) = load(__lcell1011);
+    let List.Cons(__lcell1012) = l; let (b52, l) = load(__lcell1012);
+    let List.Cons(__lcell1013) = l; let (b51, l) = load(__lcell1013);
+    let List.Cons(__lcell1014) = l; let (b50, l) = load(__lcell1014);
+    let List.Cons(__lcell1015) = l; let (b49, l) = load(__lcell1015);
+    let List.Cons(__lcell1016) = l; let (b48, l) = load(__lcell1016);
+    let List.Cons(__lcell1017) = l; let (b47, l) = load(__lcell1017);
+    let List.Cons(__lcell1018) = l; let (b46, l) = load(__lcell1018);
+    let List.Cons(__lcell1019) = l; let (b45, l) = load(__lcell1019);
+    let List.Cons(__lcell1020) = l; let (b44, l) = load(__lcell1020);
+    let List.Cons(__lcell1021) = l; let (b43, l) = load(__lcell1021);
+    let List.Cons(__lcell1022) = l; let (b42, l) = load(__lcell1022);
+    let List.Cons(__lcell1023) = l; let (b41, l) = load(__lcell1023);
+    let List.Cons(__lcell1024) = l; let (b40, l) = load(__lcell1024);
+    let List.Cons(__lcell1025) = l; let (b39, l) = load(__lcell1025);
+    let List.Cons(__lcell1026) = l; let (b38, l) = load(__lcell1026);
+    let List.Cons(__lcell1027) = l; let (b37, l) = load(__lcell1027);
+    let List.Cons(__lcell1028) = l; let (b36, l) = load(__lcell1028);
+    let List.Cons(__lcell1029) = l; let (b35, l) = load(__lcell1029);
+    let List.Cons(__lcell1030) = l; let (b34, l) = load(__lcell1030);
+    let List.Cons(__lcell1031) = l; let (b33, l) = load(__lcell1031);
+    let List.Cons(__lcell1032) = l; let (b32, l) = load(__lcell1032);
+    let List.Cons(__lcell1033) = l; let (b31, l) = load(__lcell1033);
+    let List.Cons(__lcell1034) = l; let (b30, l) = load(__lcell1034);
+    let List.Cons(__lcell1035) = l; let (b29, l) = load(__lcell1035);
+    let List.Cons(__lcell1036) = l; let (b28, l) = load(__lcell1036);
+    let List.Cons(__lcell1037) = l; let (b27, l) = load(__lcell1037);
+    let List.Cons(__lcell1038) = l; let (b26, l) = load(__lcell1038);
+    let List.Cons(__lcell1039) = l; let (b25, l) = load(__lcell1039);
+    let List.Cons(__lcell1040) = l; let (b24, l) = load(__lcell1040);
+    let List.Cons(__lcell1041) = l; let (b23, l) = load(__lcell1041);
+    let List.Cons(__lcell1042) = l; let (b22, l) = load(__lcell1042);
+    let List.Cons(__lcell1043) = l; let (b21, l) = load(__lcell1043);
+    let List.Cons(__lcell1044) = l; let (b20, l) = load(__lcell1044);
+    let List.Cons(__lcell1045) = l; let (b19, l) = load(__lcell1045);
+    let List.Cons(__lcell1046) = l; let (b18, l) = load(__lcell1046);
+    let List.Cons(__lcell1047) = l; let (b17, l) = load(__lcell1047);
+    let List.Cons(__lcell1048) = l; let (b16, l) = load(__lcell1048);
+    let List.Cons(__lcell1049) = l; let (b15, l) = load(__lcell1049);
+    let List.Cons(__lcell1050) = l; let (b14, l) = load(__lcell1050);
+    let List.Cons(__lcell1051) = l; let (b13, l) = load(__lcell1051);
+    let List.Cons(__lcell1052) = l; let (b12, l) = load(__lcell1052);
+    let List.Cons(__lcell1053) = l; let (b11, l) = load(__lcell1053);
+    let List.Cons(__lcell1054) = l; let (b10, l) = load(__lcell1054);
+    let List.Cons(__lcell1055) = l; let (b9, l) = load(__lcell1055);
+    let List.Cons(__lcell1056) = l; let (b8, l) = load(__lcell1056);
+    let List.Cons(__lcell1057) = l; let (b7, l) = load(__lcell1057);
+    let List.Cons(__lcell1058) = l; let (b6, l) = load(__lcell1058);
+    let List.Cons(__lcell1059) = l; let (b5, l) = load(__lcell1059);
+    let List.Cons(__lcell1060) = l; let (b4, l) = load(__lcell1060);
+    let List.Cons(__lcell1061) = l; let (b3, l) = load(__lcell1061);
+    let List.Cons(__lcell1062) = l; let (b2, l) = load(__lcell1062);
+    let List.Cons(__lcell1063) = l; let (b1, l) = load(__lcell1063);
+    let List.Cons(__lcell1064) = l; let (b0, _) = load(__lcell1064);
     [
       [b0, b1, b2, b3], [b4, b5, b6, b7], [b8, b9, b10, b11], [b12, b13, b14, b15],
       [b16, b17, b18, b19], [b20, b21, b22, b23], [b24, b25, b26, b27], [b28, b29, b30, b31],
@@ -228,7 +233,7 @@ def blake3 := ⟦
   fn pad_block(acc: ByteStream, n: G) -> ByteStream {
     match n {
       0 => acc,
-      _ => pad_block(store(ListNode.Cons(0u8, acc)), n - 1),
+      _ => pad_block(List.Cons(store((0u8, acc))), n - 1),
     }
   }
 
@@ -241,8 +246,8 @@ def blake3 := ⟦
     chunk_index: G,
     chunk_count: &U64,
     block_digest: &[[U8; 4]; 8],
-    layer: &Layer
-  ) -> &Layer {
+    layer: Layer
+  ) -> Layer {
     let CHUNK_START = 1;
     let CHUNK_END = 2;
     let ROOT = 8;
@@ -251,14 +256,14 @@ def blake3 := ⟦
         match load(chunk_count) {
           [0, 0, 0, 0, 0, 0, 0, 0] =>
             let flags = ROOT + CHUNK_START + CHUNK_END;
-            store(Layer.Push(layer, blake3_compress(load(block_digest), [[0u8; 4]; 16], load(chunk_count), 0, flags))),
+            Layer.Push(store((layer, blake3_compress(load(block_digest), [[0u8; 4]; 16], load(chunk_count), 0, flags)))),
           _ => layer,
         },
-      (0, _) => store(Layer.Push(layer, load(block_digest))),
+      (0, _) => Layer.Push(store((layer, load(block_digest)))),
       (_, _) =>
         let flags = CHUNK_END + u64_is_zero(load(chunk_count)) * ROOT + eq_zero(chunk_index - block_index) * CHUNK_START;
         let block = bytes_to_block(pad_block(byte_acc, 64 - block_index));
-        store(Layer.Push(layer, blake3_compress(load(block_digest), block, load(chunk_count), block_index, flags))),
+        Layer.Push(store((layer, blake3_compress(load(block_digest), block, load(chunk_count), block_index, flags)))),
     }
   }
 
@@ -271,8 +276,8 @@ def blake3 := ⟦
     chunk_index: G,
     chunk_count: &U64,
     block_digest: &[[U8; 4]; 8],
-    layer: &Layer
-  ) -> &Layer {
+    layer: Layer
+  ) -> Layer {
     let CHUNK_START = 1;
     let CHUNK_END = 2;
     let ROOT = 8;
@@ -281,15 +286,15 @@ def blake3 := ⟦
       1023 =>
         let flags = ROOT * list_is_empty(input) * u64_is_zero(load(chunk_count)) + CHUNK_END;
         let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
-        let layer = store(Layer.Push(layer, blake3_compress(load(block_digest), block, load(chunk_count), 64, flags)));
-        blake3_compress_chunks(input, store(ListNode.Nil), 0, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), layer),
+        let layer = Layer.Push(store((layer, blake3_compress(load(block_digest), block, load(chunk_count), 64, flags))));
+        blake3_compress_chunks(input, List.Nil, 0, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), layer),
       _ =>
         let chunk_end_flag = list_is_empty(input) * CHUNK_END;
         let root_flag = list_is_empty(input) * u64_is_zero(load(chunk_count)) * ROOT;
         let chunk_start_flag = eq_zero(chunk_index - 63) * CHUNK_START;
         let flags = chunk_end_flag + root_flag + chunk_start_flag;
         let block_digest = blake3_compress(load(block_digest), block, load(chunk_count), 64, flags);
-        blake3_compress_chunks(input, store(ListNode.Nil), 0, chunk_index + 1, chunk_count, store(block_digest), layer),
+        blake3_compress_chunks(input, List.Nil, 0, chunk_index + 1, chunk_count, store(block_digest), layer),
     }
   }
 
diff --git a/Ix/IxVM/ByteStream.lean b/Ix/IxVM/ByteStream.lean
index f1ab554f..ad1607d4 100644
--- a/Ix/IxVM/ByteStream.lean
+++ b/Ix/IxVM/ByteStream.lean
@@ -12,11 +12,11 @@ def byteStream := ⟦
 
   fn read_byte_stream(channel: G, idx: G, len: G) -> ByteStream {
     match len {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ =>
         let tail = read_byte_stream(channel, idx + 1, len - 1);
         let [byte] = io_read(channel, idx, 1);
-        store(ListNode.Cons(u8_from_field_unsafe(byte), tail)),
+        List.Cons(store((u8_from_field_unsafe(byte), tail))),
     }
   }
 
diff --git a/Ix/IxVM/Convert.lean b/Ix/IxVM/Convert.lean
index 6f2cfed5..619849d7 100644
--- a/Ix/IxVM/Convert.lean
+++ b/Ix/IxVM/Convert.lean
@@ -34,9 +34,9 @@ def convert := ⟦
     match pos {
       8 => acc,
       _ =>
-        match load(bytes) {
-          ListNode.Nil => acc,
-          ListNode.Cons(byte, rest) =>
+        match bytes {
+          List.Nil => acc,
+          List.Cons(__cell1) => let (byte, rest) = load(__cell1);
             let [v0, v1, v2, v3, v4, v5, v6, v7] = acc;
             match pos {
               0 => bytes_to_u64_limb(rest, [byte, v1, v2, v3, v4, v5, v6, v7], 1),
@@ -56,9 +56,9 @@ def convert := ⟦
     match n {
       0 => bytes,
       _ =>
-        match load(bytes) {
-          ListNode.Nil => store(ListNode.Nil),
-          ListNode.Cons(_, rest) => skip_bytes(rest, n - 1),
+        match bytes {
+          List.Nil => List.Nil,
+          List.Cons(__cell2) => let (_, rest) = load(__cell2); skip_bytes(rest, n - 1),
         },
     }
   }
@@ -69,17 +69,17 @@ def convert := ⟦
   fn bytes_to_limbs(bytes: ByteStream) -> KLimbs {
     let limb = bytes_to_u64_limb(bytes, [0u8; 8], 0);
     let rest_bytes = skip_bytes(bytes, 8);
-    let rest_limbs = match load(rest_bytes) {
-      ListNode.Nil => store(ListNode.Nil),
+    let rest_limbs = match rest_bytes {
+      List.Nil => List.Nil,
       _ => bytes_to_limbs(rest_bytes),
     };
-    match load(rest_limbs) {
-      ListNode.Nil =>
+    match rest_limbs {
+      List.Nil =>
         match u64_is_zero(limb) {
-          1 => store(ListNode.Nil),
-          0 => store(ListNode.Cons(limb, store(ListNode.Nil))),
+          1 => List.Nil,
+          0 => List.Cons(store((limb, List.Nil))),
         },
-      _ => store(ListNode.Cons(limb, rest_limbs)),
+      _ => List.Cons(store((limb, rest_limbs))),
     }
   }
 
@@ -95,11 +95,11 @@ def convert := ⟦
   }
 
   fn convert_univ_idxs(idxs: List‹U64›, univs: List‹&Univ›) -> List‹KLevel› {
-    match load(idxs) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(idx, rest) =>
+    match idxs {
+      List.Nil => List.Nil,
+      List.Cons(__cell3) => let (idx, rest) = load(__cell3);
         let u_ref = list_lookup(univs, flatten_u64(idx));
-        store(ListNode.Cons(convert_univ(u_ref), convert_univ_idxs(rest, univs))),
+        List.Cons(store((convert_univ(u_ref), convert_univ_idxs(rest, univs)))),
     }
   }
 
@@ -192,7 +192,7 @@ def convert := ⟦
           convert_expr(body, sharing, refs, recur_addrs, univs))),
 
       Expr.Share(idx) =>
-        let ListNode.Cons(e, _) = load(list_drop(sharing, flatten_u64(idx)));
+        let List.Cons(__lcell1001) = list_drop(sharing, flatten_u64(idx)); let (e, _) = load(__lcell1001);
         convert_expr(e, sharing, refs, recur_addrs, univs),
     }
   }
@@ -245,16 +245,16 @@ def convert := ⟦
 
   -- Count ctors in Inductive.ctors list.
   fn count_ctors(cs: List‹Constructor›) -> G {
-    match load(cs) {
-      ListNode.Nil => 0,
-      ListNode.Cons(_, rest) => count_ctors(rest) + 1,
+    match cs {
+      List.Nil => 0,
+      List.Cons(__cell4) => let (_, rest) = load(__cell4); count_ctors(rest) + 1,
     }
   }
 
   -- Look up Constructor at cidx in Inductive.ctors.
   fn ctor_at(cs: List‹Constructor›, cidx: G) -> Constructor {
-    match load(cs) {
-      ListNode.Cons(c, rest) =>
+    match cs {
+      List.Cons(__cell5) => let (c, rest) = load(__cell5);
         match cidx {
           0 => c,
           _ => ctor_at(rest, cidx - 1),
@@ -294,16 +294,16 @@ def convert := ⟦
   fn convert_rec_rules(rs: List‹RecursorRule›, sharing: List‹&Expr›,
                            refs: List‹Addr›, recur_addrs: List‹Addr›,
                            univs: List‹&Univ›, cidx: G) -> List‹KRecRule› {
-    match load(rs) {
-      ListNode.Nil =>
-        store(ListNode.Nil),
-      ListNode.Cons(r, rest) =>
+    match rs {
+      List.Nil =>
+        List.Nil,
+      List.Cons(__cell6) => let (r, rest) = load(__cell6);
         match r {
           RecursorRule.Mk(fields, rhs) =>
             let krhs = convert_expr(rhs, sharing, refs, recur_addrs, univs);
-            store(ListNode.Cons(
+            List.Cons(store((
               KRecRule.Mk(cidx, flatten_u64(fields), krhs),
-              convert_rec_rules(rest, sharing, refs, recur_addrs, univs, cidx + 1))),
+              convert_rec_rules(rest, sharing, refs, recur_addrs, univs, cidx + 1)))),
         },
     }
   }
diff --git a/Ix/IxVM/Core.lean b/Ix/IxVM/Core.lean
index a32e74d7..02f68883 100644
--- a/Ix/IxVM/Core.lean
+++ b/Ix/IxVM/Core.lean
@@ -6,13 +6,15 @@ public section
 namespace IxVM
 
 def core := ⟦
-  enum ListNode‹T› {
-    Cons(T, List‹T›),
-    Nil
+  -- Null-pointer-niche list: a `List` value is ONE field element — 0 is
+  -- Nil (the impossible pointer), anything else a pointer to the
+  -- `(head, tail)` cell. No tag slot, no stored Nil node, and emptiness
+  -- checks are a plain field match instead of a memory load.
+  enum List‹T› {
+    Nil,
+    Cons(&(T, List‹T›))
   }
 
-  type List‹T› = &ListNode‹T›
-
   enum Option‹T› {
     Some(T),
     None
@@ -140,47 +142,47 @@ def core := ⟦
   }
 
   fn list_length‹T›(list: List‹T›) -> G {
-    match load(list) {
-      ListNode.Nil => 0,
-      ListNode.Cons(_, rest) => list_length(rest) + 1,
+    match list {
+      List.Nil => 0,
+      List.Cons(__cell1) => let (_, rest) = load(__cell1); list_length(rest) + 1,
     }
   }
 
   fn list_length_u64‹T›(list: List‹T›) -> U64 {
-    match load(list) {
-      ListNode.Nil => [0u8; 8],
-      ListNode.Cons(_, rest) => relaxed_u64_succ(list_length_u64(rest)),
+    match list {
+      List.Nil => [0u8; 8],
+      List.Cons(__cell2) => let (_, rest) = load(__cell2); relaxed_u64_succ(list_length_u64(rest)),
     }
   }
 
   fn list_concat‹T›(a: List‹T›, b: List‹T›) -> List‹T› {
-    match load(a) {
-      ListNode.Nil => b,
-      ListNode.Cons(v, rest) => store(ListNode.Cons(v, list_concat(rest, b))),
+    match a {
+      List.Nil => b,
+      List.Cons(__cell3) => let (v, rest) = load(__cell3); List.Cons(store((v, list_concat(rest, b)))),
     }
   }
 
   fn list_is_empty‹T›(list: List‹T›) -> G {
-    match load(list) {
-      ListNode.Nil => 1,
-      ListNode.Cons(_, _) => 0,
+    match list {
+      List.Nil => 1,
+      List.Cons(_) => 0,
     }
   }
 
   fn list_lookup‹T›(list: List‹T›, idx: G) -> T {
-    let ListNode.Cons(v, _) = load(list_drop(list, idx));
+    let List.Cons(__lcell1001) = list_drop(list, idx); let (v, _) = load(__lcell1001);
     v
   }
 
   fn list_lookup_or_default‹T›(list: List‹T›, idx: G, default: T) -> T {
-    match load(list_drop(list, idx)) {
-      ListNode.Nil => default,
-      ListNode.Cons(v, _) => v,
+    match list_drop(list, idx) {
+      List.Nil => default,
+      List.Cons(__cell4) => let (v, _) = load(__cell4); v,
     }
   }
 
   fn list_lookup_u64‹T›(list: List‹T›, idx: U64) -> T {
-    let ListNode.Cons(v, rest) = load(list);
+    let List.Cons(__lcell1002) = list; let (v, rest) = load(__lcell1002);
     let z = u64_is_zero(idx);
     match z {
       1 => v,
@@ -192,38 +194,38 @@ def core := ⟦
     match n {
       0 => list,
       _ =>
-        let ListNode.Cons(_, rest) = load(list_drop(list, n - 1));
+        let List.Cons(__lcell1003) = list_drop(list, n - 1); let (_, rest) = load(__lcell1003);
         rest,
     }
   }
 
   fn list_take‹T›(list: List‹T›, n: G) -> List‹T› {
     match n {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ =>
-        let ListNode.Cons(v, rest) = load(list);
-        store(ListNode.Cons(v, list_take(rest, n - 1))),
+        let List.Cons(__lcell1004) = list; let (v, rest) = load(__lcell1004);
+        List.Cons(store((v, list_take(rest, n - 1)))),
     }
   }
 
   fn list_snoc‹T›(list: List‹T›, v: T) -> List‹T› {
-    match load(list) {
-      ListNode.Nil => store(ListNode.Cons(v, store(ListNode.Nil))),
-      ListNode.Cons(head, rest) => store(ListNode.Cons(head, list_snoc(rest, v))),
+    match list {
+      List.Nil => List.Cons(store((v, List.Nil))),
+      List.Cons(__cell5) => let (head, rest) = load(__cell5); List.Cons(store((head, list_snoc(rest, v)))),
     }
   }
 
   -- O(N) reverse via accumulator. Used by hot-path builders that
   -- accumulate via cons (O(1)) then reverse once instead of O(N²) snoc.
   fn list_reverse‹T›(list: List‹T›) -> List‹T› {
-    list_reverse_acc(list, store(ListNode.Nil))
+    list_reverse_acc(list, List.Nil)
   }
 
   fn list_reverse_acc‹T›(list: List‹T›, acc: List‹T›) -> List‹T› {
-    match load(list) {
-      ListNode.Nil => acc,
-      ListNode.Cons(head, rest) =>
-        list_reverse_acc(rest, store(ListNode.Cons(head, acc))),
+    match list {
+      List.Nil => acc,
+      List.Cons(__cell6) => let (head, rest) = load(__cell6);
+        list_reverse_acc(rest, List.Cons(store((head, acc)))),
     }
   }
 ⟧
diff --git a/Ix/IxVM/Ingress.lean b/Ix/IxVM/Ingress.lean
index 42e7984f..2cae5298 100644
--- a/Ix/IxVM/Ingress.lean
+++ b/Ix/IxVM/Ingress.lean
@@ -44,7 +44,7 @@ def ingress := ⟦
     let bytes = #read_byte_stream(2, idx, len);
     verify_bytes_against(bytes, raw);
     let (constant, rest) = get_constant(bytes);
-    assert_eq!(load(rest), ListNode.Nil,
+    assert_eq!(rest, List.Nil,
       "trailing bytes after constant on ch 2");
     constant
   }
@@ -55,8 +55,8 @@ def ingress := ⟦
     let raw = load(addr);
     let (idx, len) = io_get_info(3, raw);
     let bytes = #read_byte_stream(3, idx, len);
-    match load(bytes) {
-      ListNode.Cons(b, _) => to_field(b),
+    match bytes {
+      List.Cons(__cell1) => let (b, _) = load(__cell1); to_field(b),
     }
   }
 
@@ -126,7 +126,7 @@ def ingress := ⟦
     match d {
       Definition.Mk(kind, safety, _, _, _) =>
         match defn_is_unsafe_ci(kind, safety) {
-          0 => store(ListNode.Nil),
+          0 => List.Nil,
           _ => build_recur_addrs(members, block_addr),
         },
     }
@@ -168,8 +168,8 @@ def ingress := ⟦
             let self_recur = match defn {
               Definition.Mk(kind, safety, _, _, _) =>
                 match defn_is_unsafe_ci(kind, safety) {
-                  0 => store(ListNode.Nil),
-                  _ => store(ListNode.Cons(addr, store(ListNode.Nil))),
+                  0 => List.Nil,
+                  _ => List.Cons(store((addr, List.Nil))),
                 },
             };
             store(convert_definition(defn, sharing, refs,
@@ -177,10 +177,10 @@ def ingress := ⟦
           ConstantInfo.Axio(axio) =>
             -- Axiom bodies have no Rec refs; empty recur_addrs.
             store(convert_axiom(axio, sharing, refs,
-                                     store(ListNode.Nil), univs)),
+                                     List.Nil, univs)),
           ConstantInfo.Quot(quot) =>
             store(convert_quotient(quot, sharing, refs,
-                                        store(ListNode.Nil), univs)),
+                                        List.Nil, univs)),
           ConstantInfo.DPrj(prj) =>
             match prj {
               DefinitionProj.Mk(idx, block_addr) =>
@@ -224,7 +224,7 @@ def ingress := ⟦
           -- projection.
           ConstantInfo.Recr(recr) =>
             -- Standalone Recr: single recur slot = self.
-            let self_recur = store(ListNode.Cons(addr, store(ListNode.Nil)));
+            let self_recur = List.Cons(store((addr, List.Nil)));
             store(convert_recursor(recr, addr, 0,
                                         sharing, refs, self_recur, univs)),
         },
@@ -310,8 +310,8 @@ let block_c = load_verified_constant(block_addr);
 
   -- G-indexed Muts member lookup.
   fn muts_member_at(members: List‹MutConst›, idx: G) -> MutConst {
-    match load(members) {
-      ListNode.Cons(m, rest) =>
+    match members {
+      List.Cons(__cell2) => let (m, rest) = load(__cell2);
         match idx {
           0 => m,
           _ => muts_member_at(rest, idx - 1),
@@ -380,10 +380,10 @@ let block_c = load_verified_constant(block_addr);
         ConstantInfo.RPrj(RecursorProj.Mk(idx_u64, block_addr)),
     };
     let proj_c = Constant.Mk(info,
-                              store(ListNode.Nil),
-                              store(ListNode.Nil),
-                              store(ListNode.Nil));
-    let bytes = put_constant(proj_c, store(ListNode.Nil));
+                              List.Nil,
+                              List.Nil,
+                              List.Nil);
+    let bytes = put_constant(proj_c, List.Nil);
     bytes_to_addr(bytes)
   }
 
@@ -395,12 +395,12 @@ let block_c = load_verified_constant(block_addr);
 
   fn build_recur_addrs_walk(all_members: List‹MutConst›, block_addr: Addr,
                                  cur: List‹MutConst›, idx: G) -> List‹Addr› {
-    match load(cur) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(_, rest) =>
-        store(ListNode.Cons(
+    match cur {
+      List.Nil => List.Nil,
+      List.Cons(__cell3) => let (_, rest) = load(__cell3);
+        List.Cons(store((
           projection_addr(all_members, block_addr, idx),
-          build_recur_addrs_walk(all_members, block_addr, rest, idx + 1))),
+          build_recur_addrs_walk(all_members, block_addr, rest, idx + 1)))),
     }
   }
 ⟧
diff --git a/Ix/IxVM/IxonDeserialize.lean b/Ix/IxVM/IxonDeserialize.lean
index 351ff807..47591967 100644
--- a/Ix/IxVM/IxonDeserialize.lean
+++ b/Ix/IxVM/IxonDeserialize.lean
@@ -19,9 +19,9 @@ def ixonDeserialize := ⟦
   -- never over-reads). Cold once-per-constant parsers keep the call for the
   -- padding semantics and narrower circuits.
   fn read_byte(stream: ByteStream) -> (U8, ByteStream) {
-    match load(stream) {
-      ListNode.Cons(byte, rest) => (byte, rest),
-      ListNode.Nil => (0u8, store(ListNode.Nil)),
+    match stream {
+      List.Cons(__cell1) => let (byte, rest) = load(__cell1); (byte, rest),
+      List.Nil => (0u8, List.Nil),
     }
   }
 
@@ -30,7 +30,7 @@ def ixonDeserialize := ⟦
     match num_bytes {
       0 => ([0u8; 8], stream),
       _ =>
-        let ListNode.Cons(byte, s) = load(stream);
+        let List.Cons(__lcell1001) = stream; let (byte, s) = load(__lcell1001);
         let (rest_bytes, s2) = get_u64_le(s, num_bytes - 1);
         let [r0, r1, r2, r3, r4, r5, r6, _] = rest_bytes;
         ([byte, r0, r1, r2, r3, r4, r5, r6], s2),
@@ -43,7 +43,7 @@ def ixonDeserialize := ⟦
 
   -- Tag0: [large:1][size:7]
   fn get_tag0(stream: ByteStream) -> (U64, ByteStream) {
-    let ListNode.Cons(byte, s) = load(stream);
+    let List.Cons(__lcell1002) = stream; let (byte, s) = load(__lcell1002);
     let bits = u8_bit_decomposition(byte);
     let [b0, b1, b2, b3, b4, b5, b6, b7] = bits;
     let small_size = b0 + 2 * b1 + 4 * b2 + 8 * b3 + 16 * b4 + 32 * b5 + 64 * b6;
@@ -67,7 +67,7 @@ def ixonDeserialize := ⟦
 
   -- Tag2: [flag:2][large:1][size:5]
   fn get_tag2(stream: ByteStream) -> ((G, U64), ByteStream) {
-    let ListNode.Cons(byte, s) = load(stream);
+    let List.Cons(__lcell1003) = stream; let (byte, s) = load(__lcell1003);
     let bits = u8_bit_decomposition(byte);
     let [b0, b1, b2, b3, b4, b5, b6, b7] = bits;
     let flag = b6 + 2 * b7;
@@ -88,7 +88,7 @@ def ixonDeserialize := ⟦
 
   -- Tag4: [flag:4][large:1][size:3]
   fn get_tag4(stream: ByteStream) -> ((G, U64), ByteStream) {
-    let ListNode.Cons(byte, s) = load(stream);
+    let List.Cons(__lcell1004) = stream; let (byte, s) = load(__lcell1004);
     let bits = u8_bit_decomposition(byte);
     let [b0, b1, b2, b3, b4, b5, b6, b7] = bits;
     let flag = b4 + 2 * b5 + 4 * b6 + 8 * b7;
@@ -110,11 +110,11 @@ def ixonDeserialize := ⟦
   fn get_u64_list(stream: ByteStream, count: U64) -> (List‹U64›, ByteStream) {
     let is_zero = u64_is_zero(count);
     match is_zero {
-      1 => (store(ListNode.Nil), stream),
+      1 => (List.Nil, stream),
       0 =>
         let (val, s) = get_tag0(stream);
         let (rest, s2) = get_u64_list(s, relaxed_u64_pred(count));
-        (store(ListNode.Cons(val, rest)), s2),
+        (List.Cons(store((val, rest))), s2),
     }
   }
 
@@ -297,38 +297,38 @@ def ixonDeserialize := ⟦
   -- ============================================================================
 
   fn get_address(stream: ByteStream) -> (Addr, ByteStream) {
-    let ListNode.Cons(b0, s) = load(stream);
-    let ListNode.Cons(b1, s) = load(s);
-    let ListNode.Cons(b2, s) = load(s);
-    let ListNode.Cons(b3, s) = load(s);
-    let ListNode.Cons(b4, s) = load(s);
-    let ListNode.Cons(b5, s) = load(s);
-    let ListNode.Cons(b6, s) = load(s);
-    let ListNode.Cons(b7, s) = load(s);
-    let ListNode.Cons(b8, s) = load(s);
-    let ListNode.Cons(b9, s) = load(s);
-    let ListNode.Cons(b10, s) = load(s);
-    let ListNode.Cons(b11, s) = load(s);
-    let ListNode.Cons(b12, s) = load(s);
-    let ListNode.Cons(b13, s) = load(s);
-    let ListNode.Cons(b14, s) = load(s);
-    let ListNode.Cons(b15, s) = load(s);
-    let ListNode.Cons(b16, s) = load(s);
-    let ListNode.Cons(b17, s) = load(s);
-    let ListNode.Cons(b18, s) = load(s);
-    let ListNode.Cons(b19, s) = load(s);
-    let ListNode.Cons(b20, s) = load(s);
-    let ListNode.Cons(b21, s) = load(s);
-    let ListNode.Cons(b22, s) = load(s);
-    let ListNode.Cons(b23, s) = load(s);
-    let ListNode.Cons(b24, s) = load(s);
-    let ListNode.Cons(b25, s) = load(s);
-    let ListNode.Cons(b26, s) = load(s);
-    let ListNode.Cons(b27, s) = load(s);
-    let ListNode.Cons(b28, s) = load(s);
-    let ListNode.Cons(b29, s) = load(s);
-    let ListNode.Cons(b30, s) = load(s);
-    let ListNode.Cons(b31, s) = load(s);
+    let List.Cons(__lcell1005) = stream; let (b0, s) = load(__lcell1005);
+    let List.Cons(__lcell1006) = s; let (b1, s) = load(__lcell1006);
+    let List.Cons(__lcell1007) = s; let (b2, s) = load(__lcell1007);
+    let List.Cons(__lcell1008) = s; let (b3, s) = load(__lcell1008);
+    let List.Cons(__lcell1009) = s; let (b4, s) = load(__lcell1009);
+    let List.Cons(__lcell1010) = s; let (b5, s) = load(__lcell1010);
+    let List.Cons(__lcell1011) = s; let (b6, s) = load(__lcell1011);
+    let List.Cons(__lcell1012) = s; let (b7, s) = load(__lcell1012);
+    let List.Cons(__lcell1013) = s; let (b8, s) = load(__lcell1013);
+    let List.Cons(__lcell1014) = s; let (b9, s) = load(__lcell1014);
+    let List.Cons(__lcell1015) = s; let (b10, s) = load(__lcell1015);
+    let List.Cons(__lcell1016) = s; let (b11, s) = load(__lcell1016);
+    let List.Cons(__lcell1017) = s; let (b12, s) = load(__lcell1017);
+    let List.Cons(__lcell1018) = s; let (b13, s) = load(__lcell1018);
+    let List.Cons(__lcell1019) = s; let (b14, s) = load(__lcell1019);
+    let List.Cons(__lcell1020) = s; let (b15, s) = load(__lcell1020);
+    let List.Cons(__lcell1021) = s; let (b16, s) = load(__lcell1021);
+    let List.Cons(__lcell1022) = s; let (b17, s) = load(__lcell1022);
+    let List.Cons(__lcell1023) = s; let (b18, s) = load(__lcell1023);
+    let List.Cons(__lcell1024) = s; let (b19, s) = load(__lcell1024);
+    let List.Cons(__lcell1025) = s; let (b20, s) = load(__lcell1025);
+    let List.Cons(__lcell1026) = s; let (b21, s) = load(__lcell1026);
+    let List.Cons(__lcell1027) = s; let (b22, s) = load(__lcell1027);
+    let List.Cons(__lcell1028) = s; let (b23, s) = load(__lcell1028);
+    let List.Cons(__lcell1029) = s; let (b24, s) = load(__lcell1029);
+    let List.Cons(__lcell1030) = s; let (b25, s) = load(__lcell1030);
+    let List.Cons(__lcell1031) = s; let (b26, s) = load(__lcell1031);
+    let List.Cons(__lcell1032) = s; let (b27, s) = load(__lcell1032);
+    let List.Cons(__lcell1033) = s; let (b28, s) = load(__lcell1033);
+    let List.Cons(__lcell1034) = s; let (b29, s) = load(__lcell1034);
+    let List.Cons(__lcell1035) = s; let (b30, s) = load(__lcell1035);
+    let List.Cons(__lcell1036) = s; let (b31, s) = load(__lcell1036);
     (store([b0, b1, b2,
       b3, b4, b5,
       b6, b7, b8,
@@ -349,33 +349,33 @@ def ixonDeserialize := ⟦
   fn get_expr_list(stream: ByteStream, count: U64) -> (List‹&Expr›, ByteStream) {
     let is_zero = u64_is_zero(count);
     match is_zero {
-      1 => (store(ListNode.Nil), stream),
+      1 => (List.Nil, stream),
       0 =>
         let (expr, s) = get_expr(stream);
         let (rest, s2) = get_expr_list(s, relaxed_u64_pred(count));
-        (store(ListNode.Cons(expr, rest)), s2),
+        (List.Cons(store((expr, rest))), s2),
     }
   }
 
   fn get_univ_list(stream: ByteStream, count: U64) -> (List‹&Univ›, ByteStream) {
     let is_zero = u64_is_zero(count);
     match is_zero {
-      1 => (store(ListNode.Nil), stream),
+      1 => (List.Nil, stream),
       0 =>
         let (u, s) = get_univ(stream);
         let (rest, s2) = get_univ_list(s, relaxed_u64_pred(count));
-        (store(ListNode.Cons(store(u), rest)), s2),
+        (List.Cons(store((store(u), rest))), s2),
     }
   }
 
   fn get_address_list(stream: ByteStream, count: U64) -> (List‹Addr›, ByteStream) {
     let is_zero = u64_is_zero(count);
     match is_zero {
-      1 => (store(ListNode.Nil), stream),
+      1 => (List.Nil, stream),
       0 =>
         let (addr, s) = get_address(stream);
         let (rest, s2) = get_address_list(s, relaxed_u64_pred(count));
-        (store(ListNode.Cons(addr, rest)), s2),
+        (List.Cons(store((addr, rest))), s2),
     }
   }
 
@@ -440,11 +440,11 @@ def ixonDeserialize := ⟦
   fn get_recursor_rule_list(stream: ByteStream, count: U64) -> (List‹RecursorRule›, ByteStream) {
     let is_zero = u64_is_zero(count);
     match is_zero {
-      1 => (store(ListNode.Nil), stream),
+      1 => (List.Nil, stream),
       0 =>
         let (rule, s) = @get_recursor_rule(stream);
         let (rest, s2) = get_recursor_rule_list(s, relaxed_u64_pred(count));
-        (store(ListNode.Cons(rule, rest)), s2),
+        (List.Cons(store((rule, rest))), s2),
     }
   }
 
@@ -524,11 +524,11 @@ def ixonDeserialize := ⟦
   fn get_constructor_list(stream: ByteStream, count: U64) -> (List‹Constructor›, ByteStream) {
     let is_zero = u64_is_zero(count);
     match is_zero {
-      1 => (store(ListNode.Nil), stream),
+      1 => (List.Nil, stream),
       0 =>
         let (ctor, s) = get_constructor(stream);
         let (rest, s2) = get_constructor_list(s, relaxed_u64_pred(count));
-        (store(ListNode.Cons(ctor, rest)), s2),
+        (List.Cons(store((ctor, rest))), s2),
     }
   }
 
@@ -603,11 +603,11 @@ def ixonDeserialize := ⟦
   fn get_mut_const_list(stream: ByteStream, count: U64) -> (List‹MutConst›, ByteStream) {
     let is_zero = u64_is_zero(count);
     match is_zero {
-      1 => (store(ListNode.Nil), stream),
+      1 => (List.Nil, stream),
       0 =>
         let (mc, s) = get_mut_const(stream);
         let (rest, s2) = get_mut_const_list(s, relaxed_u64_pred(count));
-        (store(ListNode.Cons(mc, rest)), s2),
+        (List.Cons(store((mc, rest))), s2),
     }
   }
 
diff --git a/Ix/IxVM/IxonSerialize.lean b/Ix/IxVM/IxonSerialize.lean
index 6ae3d901..c1055c87 100644
--- a/Ix/IxVM/IxonSerialize.lean
+++ b/Ix/IxVM/IxonSerialize.lean
@@ -65,7 +65,7 @@ def ixonSerialize := ⟦
       _ =>
         let [b1, b2, b3, b4, b5, b6, b7, b8] = bs;
         let rest_shifted = [b2, b3, b4, b5, b6, b7, b8, 0u8];
-        store(ListNode.Cons(b1, put_u64_le(rest_shifted, num_bytes - 1, rest))),
+        List.Cons(store((b1, put_u64_le(rest_shifted, num_bytes - 1, rest)))),
     }
   }
 
@@ -73,10 +73,10 @@ def ixonSerialize := ⟦
     let byte_count = u64_byte_count(bs);
     let small = u8_less_than(bs[0], 128u8);
     match (byte_count, small) {
-      (1, 1) => store(ListNode.Cons(bs[0], rest)),
+      (1, 1) => List.Cons(store((bs[0], rest))),
       _ =>
         let head = u8_from_field_unsafe(128 + (to_field(byte_count) - 1));
-        store(ListNode.Cons(head, put_u64_le(bs, to_field(byte_count), rest))),
+        List.Cons(store((head, put_u64_le(bs, to_field(byte_count), rest)))),
     }
   }
 
@@ -89,11 +89,11 @@ def ixonSerialize := ⟦
       (1, 1) =>
         -- Single byte: flag in bits 6-7, size in bits 0-4
         let head = u8_from_field_unsafe(flag * 64 + to_field(size[0]));
-        store(ListNode.Cons(head, rest)),
+        List.Cons(store((head, rest))),
       _ =>
         -- Multi-byte: flag in bits 6-7, large=1 in bit 5, size_bytes-1 in bits 0-4
         let head = u8_from_field_unsafe(flag * 64 + 32 + (to_field(byte_count) - 1));
-        store(ListNode.Cons(head, put_u64_le(size, to_field(byte_count), rest))),
+        List.Cons(store((head, put_u64_le(size, to_field(byte_count), rest)))),
     }
   }
 
@@ -103,18 +103,18 @@ def ixonSerialize := ⟦
     match (byte_count, small) {
       (1, 1) =>
         let head = u8_from_field_unsafe(flag * 16 + to_field(bs[0]));
-        store(ListNode.Cons(head, rest)),
+        List.Cons(store((head, rest))),
       _ =>
         let head = u8_from_field_unsafe(flag * 16 + 8 + (to_field(byte_count) - 1));
-        store(ListNode.Cons(head, put_u64_le(bs, to_field(byte_count), rest))),
+        List.Cons(store((head, put_u64_le(bs, to_field(byte_count), rest)))),
     }
   }
 
   -- Serialize field list (each element as Tag0)
   fn put_u64_list(list: List‹U64›, rest: ByteStream) -> ByteStream {
-    match load(list) {
-      ListNode.Nil => rest,
-      ListNode.Cons(idx, rest_list) =>
+    match list {
+      List.Nil => rest,
+      List.Cons(__cell1) => let (idx, rest_list) = load(__cell1);
         put_tag0(idx, put_u64_list(rest_list, rest)),
     }
   }
@@ -173,38 +173,38 @@ def ixonSerialize := ⟦
   -- Write a 32-byte address
   fn put_address(a: Addr, rest: ByteStream) -> ByteStream {
     let arr = load(a);
-    let list31 = store(ListNode.Cons(arr[31], rest));
-    let list30 = store(ListNode.Cons(arr[30], list31));
-    let list29 = store(ListNode.Cons(arr[29], list30));
-    let list28 = store(ListNode.Cons(arr[28], list29));
-    let list27 = store(ListNode.Cons(arr[27], list28));
-    let list26 = store(ListNode.Cons(arr[26], list27));
-    let list25 = store(ListNode.Cons(arr[25], list26));
-    let list24 = store(ListNode.Cons(arr[24], list25));
-    let list23 = store(ListNode.Cons(arr[23], list24));
-    let list22 = store(ListNode.Cons(arr[22], list23));
-    let list21 = store(ListNode.Cons(arr[21], list22));
-    let list20 = store(ListNode.Cons(arr[20], list21));
-    let list19 = store(ListNode.Cons(arr[19], list20));
-    let list18 = store(ListNode.Cons(arr[18], list19));
-    let list17 = store(ListNode.Cons(arr[17], list18));
-    let list16 = store(ListNode.Cons(arr[16], list17));
-    let list15 = store(ListNode.Cons(arr[15], list16));
-    let list14 = store(ListNode.Cons(arr[14], list15));
-    let list13 = store(ListNode.Cons(arr[13], list14));
-    let list12 = store(ListNode.Cons(arr[12], list13));
-    let list11 = store(ListNode.Cons(arr[11], list12));
-    let list10 = store(ListNode.Cons(arr[10], list11));
-    let list9 = store(ListNode.Cons(arr[9], list10));
-    let list8 = store(ListNode.Cons(arr[8], list9));
-    let list7 = store(ListNode.Cons(arr[7], list8));
-    let list6 = store(ListNode.Cons(arr[6], list7));
-    let list5 = store(ListNode.Cons(arr[5], list6));
-    let list4 = store(ListNode.Cons(arr[4], list5));
-    let list3 = store(ListNode.Cons(arr[3], list4));
-    let list2 = store(ListNode.Cons(arr[2], list3));
-    let list1 = store(ListNode.Cons(arr[1], list2));
-    store(ListNode.Cons(arr[0], list1))
+    let list31 = List.Cons(store((arr[31], rest)));
+    let list30 = List.Cons(store((arr[30], list31)));
+    let list29 = List.Cons(store((arr[29], list30)));
+    let list28 = List.Cons(store((arr[28], list29)));
+    let list27 = List.Cons(store((arr[27], list28)));
+    let list26 = List.Cons(store((arr[26], list27)));
+    let list25 = List.Cons(store((arr[25], list26)));
+    let list24 = List.Cons(store((arr[24], list25)));
+    let list23 = List.Cons(store((arr[23], list24)));
+    let list22 = List.Cons(store((arr[22], list23)));
+    let list21 = List.Cons(store((arr[21], list22)));
+    let list20 = List.Cons(store((arr[20], list21)));
+    let list19 = List.Cons(store((arr[19], list20)));
+    let list18 = List.Cons(store((arr[18], list19)));
+    let list17 = List.Cons(store((arr[17], list18)));
+    let list16 = List.Cons(store((arr[16], list17)));
+    let list15 = List.Cons(store((arr[15], list16)));
+    let list14 = List.Cons(store((arr[14], list15)));
+    let list13 = List.Cons(store((arr[13], list14)));
+    let list12 = List.Cons(store((arr[12], list13)));
+    let list11 = List.Cons(store((arr[11], list12)));
+    let list10 = List.Cons(store((arr[10], list11)));
+    let list9 = List.Cons(store((arr[9], list10)));
+    let list8 = List.Cons(store((arr[8], list9)));
+    let list7 = List.Cons(store((arr[7], list8)));
+    let list6 = List.Cons(store((arr[6], list7)));
+    let list5 = List.Cons(store((arr[5], list6)));
+    let list4 = List.Cons(store((arr[4], list5)));
+    let list3 = List.Cons(store((arr[3], list4)));
+    let list2 = List.Cons(store((arr[2], list3)));
+    let list1 = List.Cons(store((arr[1], list2)));
+    List.Cons(store((arr[0], list1)))
   }
 
   -- Pack DefKind (2 bits) and DefinitionSafety (2 bits) into a single byte
@@ -246,7 +246,7 @@ def ixonSerialize := ⟦
     match u {
       Univ.Zero =>
         -- Tag2(FLAG_ZERO_SUCC=0, size=0)
-        store(ListNode.Cons(0u8, rest)),
+        List.Cons(store((0u8, rest))),
 
       Univ.Succ(_) =>
         -- Count nested Succs for telescope compression
@@ -275,25 +275,29 @@ def ixonSerialize := ⟦
   -- ============================================================================
 
   fn put_expr_list(list: List‹&Expr›, rest: ByteStream) -> ByteStream {
-    match load(list) {
-      ListNode.Nil => rest,
-      ListNode.Cons(&expr, rest_list) =>
+    match list {
+      List.Nil => rest,
+      List.Cons(__cell_pe) =>
+        let (__eptr, rest_list) = load(__cell_pe);
+        let expr = load(__eptr);
         put_expr(expr, put_expr_list(rest_list, rest)),
     }
   }
 
   fn put_univ_list(list: List‹&Univ›, rest: ByteStream) -> ByteStream {
-    match load(list) {
-      ListNode.Nil => rest,
-      ListNode.Cons(&u, rest_list) =>
+    match list {
+      List.Nil => rest,
+      List.Cons(__cell_pu) =>
+        let (__uptr, rest_list) = load(__cell_pu);
+        let u = load(__uptr);
         put_univ(u, put_univ_list(rest_list, rest)),
     }
   }
 
   fn put_address_list(list: List‹Addr›, rest: ByteStream) -> ByteStream {
-    match load(list) {
-      ListNode.Nil => rest,
-      ListNode.Cons(addr, rest_list) =>
+    match list {
+      List.Nil => rest,
+      List.Cons(__cell2) => let (addr, rest_list) = load(__cell2);
         put_address(addr, put_address_list(rest_list, rest)),
     }
   }
@@ -304,10 +308,10 @@ def ixonSerialize := ⟦
 
   fn put_quot_kind(kind: QuotKind, rest: ByteStream) -> ByteStream {
     match kind {
-      QuotKind.Typ => store(ListNode.Cons(0u8, rest)),
-      QuotKind.Ctor => store(ListNode.Cons(1u8, rest)),
-      QuotKind.Lift => store(ListNode.Cons(2u8, rest)),
-      QuotKind.Ind => store(ListNode.Cons(3u8, rest)),
+      QuotKind.Typ => List.Cons(store((0u8, rest))),
+      QuotKind.Ctor => List.Cons(store((1u8, rest))),
+      QuotKind.Lift => List.Cons(store((2u8, rest))),
+      QuotKind.Ind => List.Cons(store((3u8, rest))),
     }
   }
 
@@ -315,7 +319,7 @@ def ixonSerialize := ⟦
     match defn {
       Definition.Mk(kind, safety, lvls, &typ, &value) =>
         let packed = pack_def_kind_safety(kind, safety);
-        store(ListNode.Cons(u8_from_field_unsafe(packed), put_tag0(lvls, put_expr(typ, put_expr(value, rest))))),
+        List.Cons(store((u8_from_field_unsafe(packed), put_tag0(lvls, put_expr(typ, put_expr(value, rest)))))),
     }
   }
 
@@ -327,9 +331,9 @@ def ixonSerialize := ⟦
   }
 
   fn put_recursor_rule_list(list: List‹RecursorRule›, rest: ByteStream) -> ByteStream {
-    match load(list) {
-      ListNode.Nil => rest,
-      ListNode.Cons(rule, rest_list) =>
+    match list {
+      List.Nil => rest,
+      List.Cons(__cell3) => let (rule, rest_list) = load(__cell3);
         put_recursor_rule(rule, put_recursor_rule_list(rest_list, rest)),
     }
   }
@@ -339,7 +343,7 @@ def ixonSerialize := ⟦
       Recursor.Mk(k, is_unsafe, lvls, params, indices, motives, minors, &typ, rules) =>
         let bools = k + 2 * is_unsafe;
         let rules_len = list_length_u64(rules);
-        store(ListNode.Cons(u8_from_field_unsafe(bools),
+        List.Cons(store((u8_from_field_unsafe(bools),
           put_tag0(lvls,
             put_tag0(params,
               put_tag0(indices,
@@ -347,14 +351,14 @@ def ixonSerialize := ⟦
                   put_tag0(minors,
                     put_expr(typ,
                       put_tag0(rules_len,
-                        put_recursor_rule_list(rules, rest)))))))))),
+                        put_recursor_rule_list(rules, rest))))))))))),
     }
   }
 
   fn put_axiom(axim: Axiom, rest: ByteStream) -> ByteStream {
     match axim {
       Axiom.Mk(is_unsafe, lvls, &typ) =>
-        store(ListNode.Cons(u8_from_field_unsafe(is_unsafe), put_tag0(lvls, put_expr(typ, rest)))),
+        List.Cons(store((u8_from_field_unsafe(is_unsafe), put_tag0(lvls, put_expr(typ, rest))))),
     }
   }
 
@@ -368,19 +372,19 @@ def ixonSerialize := ⟦
   fn put_constructor(ctor: Constructor, rest: ByteStream) -> ByteStream {
     match ctor {
       Constructor.Mk(is_unsafe, lvls, cidx, params, fields, &typ) =>
-        store(ListNode.Cons(u8_from_field_unsafe(is_unsafe),
+        List.Cons(store((u8_from_field_unsafe(is_unsafe),
           put_tag0(lvls,
             put_tag0(cidx,
               put_tag0(params,
                 put_tag0(fields,
-                  put_expr(typ, rest))))))),
+                  put_expr(typ, rest)))))))),
     }
   }
 
   fn put_constructor_list(list: List‹Constructor›, rest: ByteStream) -> ByteStream {
-    match load(list) {
-      ListNode.Nil => rest,
-      ListNode.Cons(ctor, rest_list) =>
+    match list {
+      List.Nil => rest,
+      List.Cons(__cell4) => let (ctor, rest_list) = load(__cell4);
         put_constructor(ctor, put_constructor_list(rest_list, rest)),
     }
   }
@@ -389,13 +393,13 @@ def ixonSerialize := ⟦
     match indc {
       Inductive.Mk(is_unsafe, lvls, params, indices, &typ, ctors) =>
         let ctors_len = list_length_u64(ctors);
-        store(ListNode.Cons(u8_from_field_unsafe(is_unsafe),
+        List.Cons(store((u8_from_field_unsafe(is_unsafe),
           put_tag0(lvls,
             put_tag0(params,
               put_tag0(indices,
                 put_expr(typ,
                   put_tag0(ctors_len,
-                    put_constructor_list(ctors, rest)))))))),
+                    put_constructor_list(ctors, rest))))))))),
     }
   }
 
@@ -430,18 +434,18 @@ def ixonSerialize := ⟦
   fn put_mut_const(mc: MutConst, rest: ByteStream) -> ByteStream {
     match mc {
       MutConst.Defn(defn) =>
-        store(ListNode.Cons(0u8, put_definition(defn, rest))),
+        List.Cons(store((0u8, put_definition(defn, rest)))),
       MutConst.Indc(indc) =>
-        store(ListNode.Cons(1u8, put_inductive(indc, rest))),
+        List.Cons(store((1u8, put_inductive(indc, rest)))),
       MutConst.Recr(recr) =>
-        store(ListNode.Cons(2u8, put_recursor(recr, rest))),
+        List.Cons(store((2u8, put_recursor(recr, rest)))),
     }
   }
 
   fn put_mut_const_list(list: List‹MutConst›, rest: ByteStream) -> ByteStream {
-    match load(list) {
-      ListNode.Nil => rest,
-      ListNode.Cons(mc, rest_list) =>
+    match list {
+      List.Nil => rest,
+      List.Cons(__cell5) => let (mc, rest_list) = load(__cell5);
         put_mut_const(mc, put_mut_const_list(rest_list, rest)),
     }
   }
diff --git a/Ix/IxVM/Kernel/CanonicalCheck.lean b/Ix/IxVM/Kernel/CanonicalCheck.lean
index e778d832..47c46f5e 100644
--- a/Ix/IxVM/Kernel/CanonicalCheck.lean
+++ b/Ix/IxVM/Kernel/CanonicalCheck.lean
@@ -105,9 +105,9 @@ def canonicalCheck := ⟦
   -- Returns 1+class if found, 0 otherwise.
   -- ==========================================================================
   fn canon_ctx_class_idx(a: Addr, ctx: List‹(Addr, G)›) -> G {
-    match load(ctx) {
-      ListNode.Nil => 0,
-      ListNode.Cons(entry, rest) =>
+    match ctx {
+      List.Nil => 0,
+      List.Cons(__cell1) => let (entry, rest) = load(__cell1);
         match entry {
           (ea, j) =>
             match address_eq(a, ea) {
@@ -185,16 +185,16 @@ def canonicalCheck := ⟦
   }
 
   fn canon_cmp_kuniv_list(xs: List‹KLevel›, ys: List‹KLevel›) -> G {
-    match load(xs) {
-      ListNode.Nil =>
-        match load(ys) {
-          ListNode.Nil => 1,
+    match xs {
+      List.Nil =>
+        match ys {
+          List.Nil => 1,
           _ => 0,
         },
-      ListNode.Cons(xh, xt) =>
-        match load(ys) {
-          ListNode.Nil => 2,
-          ListNode.Cons(yh, yt) =>
+      List.Cons(__cell2) => let (xh, xt) = load(__cell2);
+        match ys {
+          List.Nil => 2,
+          List.Cons(__cell3) => let (yh, yt) = load(__cell3);
             canon_ord_then(canon_cmp_kuniv(xh, yh), canon_cmp_kuniv_list(xt, yt)),
         },
     }
@@ -229,11 +229,11 @@ def canonicalCheck := ⟦
   }
 
   fn canon_cmp_klimbs_tail(x: KLimbs, y: KLimbs) -> G {
-    match load(x) {
-      ListNode.Nil => 1,
-      ListNode.Cons(xh, xt) =>
-        match load(y) {
-          ListNode.Cons(yh, yt) =>
+    match x {
+      List.Nil => 1,
+      List.Cons(__cell4) => let (xh, xt) = load(__cell4);
+        match y {
+          List.Cons(__cell5) => let (yh, yt) = load(__cell5);
             let tail_ord = canon_cmp_klimbs_tail(xt, yt);
             canon_ord_then(tail_ord, canon_cmp_u64_lex(xh, yh)),
         },
@@ -254,16 +254,16 @@ def canonicalCheck := ⟦
   }
 
   fn canon_cmp_bytes(x: ByteStream, y: ByteStream) -> G {
-    match load(x) {
-      ListNode.Nil =>
-        match load(y) {
-          ListNode.Nil => 1,
+    match x {
+      List.Nil =>
+        match y {
+          List.Nil => 1,
           _ => 0,
         },
-      ListNode.Cons(xh, xt) =>
-        match load(y) {
-          ListNode.Nil => 2,
-          ListNode.Cons(yh, yt) =>
+      List.Cons(__cell6) => let (xh, xt) = load(__cell6);
+        match y {
+          List.Nil => 2,
+          List.Cons(__cell7) => let (yh, yt) = load(__cell7);
             canon_ord_then(canon_ord_cmp_g(to_field(xh), to_field(yh)),
                          canon_cmp_bytes(xt, yt)),
         },
@@ -387,16 +387,16 @@ def canonicalCheck := ⟦
 
   fn canon_cmp_krec_rule_list_ctx(xs: List‹KRecRule›, ys: List‹KRecRule›,
                                 ctx: List‹(Addr, G)›) -> (G, G) {
-    match load(xs) {
-      ListNode.Nil =>
-        match load(ys) {
-          ListNode.Nil => canon_sord_eq_strong(),
+    match xs {
+      List.Nil =>
+        match ys {
+          List.Nil => canon_sord_eq_strong(),
           _ => canon_sord_lt_strong(),
         },
-      ListNode.Cons(xh, xt) =>
-        match load(ys) {
-          ListNode.Nil => canon_sord_gt_strong(),
-          ListNode.Cons(yh, yt) =>
+      List.Cons(__cell8) => let (xh, xt) = load(__cell8);
+        match ys {
+          List.Nil => canon_sord_gt_strong(),
+          List.Cons(__cell9) => let (yh, yt) = load(__cell9);
             canon_sord_then(canon_cmp_krec_rule_ctx(xh, yh, ctx),
                           canon_cmp_krec_rule_list_ctx(xt, yt, ctx)),
         },
@@ -543,10 +543,10 @@ def canonicalCheck := ⟦
     let info = ConstantInfo.CPrj(ConstructorProj.Mk(
       idx_to_u64(ind_idx), idx_to_u64(cidx), block));
     let proj_c = Constant.Mk(info,
-                             store(ListNode.Nil),
-                             store(ListNode.Nil),
-                             store(ListNode.Nil));
-    let bytes = put_constant(proj_c, store(ListNode.Nil));
+                             List.Nil,
+                             List.Nil,
+                             List.Nil);
+    let bytes = put_constant(proj_c, List.Nil);
     bytes_to_addr(bytes)
   }
 
@@ -576,9 +576,9 @@ def canonicalCheck := ⟦
 
   fn canon_build_ctx_classes(classes: List‹List‹G››, proj_addrs: List‹Addr›,
                            block: Addr, j: G, i: G) -> List‹(Addr, G)› {
-    match load(classes) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(cls, rest) =>
+    match classes {
+      List.Nil => List.Nil,
+      List.Cons(__cell10) => let (cls, rest) = load(__cell10);
         let (entries, max_ctors) =
           canon_build_ctx_members(cls, proj_addrs, block, j, i);
         list_concat(entries,
@@ -589,16 +589,16 @@ def canonicalCheck := ⟦
   fn canon_build_ctx_members(members: List‹G›, proj_addrs: List‹Addr›,
                            block: Addr, j: G, i: G)
                            -> (List‹(Addr, G)›, G) {
-    match load(members) {
-      ListNode.Nil => (store(ListNode.Nil), 0),
-      ListNode.Cons(pos, rest) =>
+    match members {
+      List.Nil => (List.Nil, 0),
+      List.Cons(__cell11) => let (pos, rest) = load(__cell11);
         let (rest_entries, rest_max) =
           canon_build_ctx_members(rest, proj_addrs, block, j, i);
         let n = canon_member_num_ctors(proj_addrs, pos);
         let ctor_entries = canon_ctor_ctx_entries(block, pos, n, i, 0);
-        let entries = store(ListNode.Cons(
+        let entries = List.Cons(store((
           (list_lookup(proj_addrs, pos), j),
-          list_concat(ctor_entries, rest_entries)));
+          list_concat(ctor_entries, rest_entries))));
         match u32_less_than(rest_max, n) {
           1 => (entries, n),
           _ => (entries, rest_max),
@@ -609,10 +609,10 @@ def canonicalCheck := ⟦
   fn canon_ctor_ctx_entries(block: Addr, ind_idx: G, n: G, i: G,
                           cidx: G) -> List‹(Addr, G)› {
     match n - cidx {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ =>
-        store(ListNode.Cons((canon_cprj_addr(block, ind_idx, cidx), i + cidx),
-          canon_ctor_ctx_entries(block, ind_idx, n, i, cidx + 1))),
+        List.Cons(store(((canon_cprj_addr(block, ind_idx, cidx), i + cidx),
+          canon_ctor_ctx_entries(block, ind_idx, n, i, cidx + 1)))),
     }
   }
 
@@ -623,7 +623,7 @@ def canonicalCheck := ⟦
   -- ==========================================================================
   fn canon_sort_members(members: List‹G›, proj_addrs: List‹Addr›,
                       block: Addr) -> List‹List‹G›› {
-    let seed = store(ListNode.Cons(members, store(ListNode.Nil)));
+    let seed = List.Cons(store((members, List.Nil)));
     canon_sort_loop(seed, proj_addrs, block, 1 + list_length(members))
   }
 
@@ -643,9 +643,9 @@ def canonicalCheck := ⟦
 
   fn canon_refine_classes(classes: List‹List‹G››, ctx: List‹(Addr, G)›,
                         proj_addrs: List‹Addr›) -> List‹List‹G›› {
-    match load(classes) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(c, rest) =>
+    match classes {
+      List.Nil => List.Nil,
+      List.Cons(__cell12) => let (c, rest) = load(__cell12);
         let refined = canon_refine_one(c, ctx, proj_addrs);
         list_concat(refined, canon_refine_classes(rest, ctx, proj_addrs)),
     }
@@ -654,8 +654,8 @@ def canonicalCheck := ⟦
   fn canon_refine_one(c: List‹G›, ctx: List‹(Addr, G)›,
                     proj_addrs: List‹Addr›) -> List‹List‹G›› {
     match list_length(c) {
-      0 => store(ListNode.Nil),
-      1 => store(ListNode.Cons(c, store(ListNode.Nil))),
+      0 => List.Nil,
+      1 => List.Cons(store((c, List.Nil))),
       _ =>
         let sorted = canon_ins_sort(c, ctx, proj_addrs);
         canon_group_consec(sorted, ctx, proj_addrs),
@@ -664,9 +664,9 @@ def canonicalCheck := ⟦
 
   fn canon_ins_sort(xs: List‹G›, ctx: List‹(Addr, G)›,
                   proj_addrs: List‹Addr›) -> List‹G› {
-    match load(xs) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(x, rest) =>
+    match xs {
+      List.Nil => List.Nil,
+      List.Cons(__cell13) => let (x, rest) = load(__cell13);
         canon_insert_sorted(x, canon_ins_sort(rest, ctx, proj_addrs),
                           ctx, proj_addrs),
     }
@@ -674,57 +674,57 @@ def canonicalCheck := ⟦
 
   fn canon_insert_sorted(x: G, sorted: List‹G›, ctx: List‹(Addr, G)›,
                        proj_addrs: List‹Addr›) -> List‹G› {
-    match load(sorted) {
-      ListNode.Nil => store(ListNode.Cons(x, store(ListNode.Nil))),
-      ListNode.Cons(h, rest) =>
+    match sorted {
+      List.Nil => List.Cons(store((x, List.Nil))),
+      List.Cons(__cell14) => let (h, rest) = load(__cell14);
         match canon_cmp_member_ctx(canon_member_ci(proj_addrs, x),
                                  canon_member_ci(proj_addrs, h), ctx) {
-          (0, _) => store(ListNode.Cons(x, sorted)),
-          _ => store(ListNode.Cons(h,
-                 canon_insert_sorted(x, rest, ctx, proj_addrs))),
+          (0, _) => List.Cons(store((x, sorted))),
+          _ => List.Cons(store((h,
+                 canon_insert_sorted(x, rest, ctx, proj_addrs)))),
         },
     }
   }
 
   fn canon_group_consec(sorted: List‹G›, ctx: List‹(Addr, G)›,
                       proj_addrs: List‹Addr›) -> List‹List‹G›› {
-    match load(sorted) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(h, rest) =>
+    match sorted {
+      List.Nil => List.Nil,
+      List.Cons(__cell15) => let (h, rest) = load(__cell15);
         canon_group_walk(rest, ctx, proj_addrs, h,
-                       store(ListNode.Cons(h, store(ListNode.Nil)))),
+                       List.Cons(store((h, List.Nil)))),
     }
   }
 
   fn canon_group_walk(remaining: List‹G›, ctx: List‹(Addr, G)›,
                     proj_addrs: List‹Addr›, last: G,
                     current: List‹G›) -> List‹List‹G›› {
-    match load(remaining) {
-      ListNode.Nil => store(ListNode.Cons(current, store(ListNode.Nil))),
-      ListNode.Cons(h, rest) =>
+    match remaining {
+      List.Nil => List.Cons(store((current, List.Nil))),
+      List.Cons(__cell16) => let (h, rest) = load(__cell16);
         match canon_cmp_member_ctx(canon_member_ci(proj_addrs, last),
                                  canon_member_ci(proj_addrs, h), ctx) {
           (1, _) =>
             canon_group_walk(rest, ctx, proj_addrs, h, list_snoc(current, h)),
           _ =>
-            store(ListNode.Cons(current,
+            List.Cons(store((current,
               canon_group_walk(rest, ctx, proj_addrs, h,
-                store(ListNode.Cons(h, store(ListNode.Nil)))))),
+                List.Cons(store((h, List.Nil))))))),
         },
     }
   }
 
   fn canon_classes_eq(a: List‹List‹G››, b: List‹List‹G››) -> G {
-    match load(a) {
-      ListNode.Nil =>
-        match load(b) {
-          ListNode.Nil => 1,
+    match a {
+      List.Nil =>
+        match b {
+          List.Nil => 1,
           _ => 0,
         },
-      ListNode.Cons(ah, arest) =>
-        match load(b) {
-          ListNode.Nil => 0,
-          ListNode.Cons(bh, brest) =>
+      List.Cons(__cell17) => let (ah, arest) = load(__cell17);
+        match b {
+          List.Nil => 0,
+          List.Cons(__cell18) => let (bh, brest) = load(__cell18);
             match canon_g_list_eq(ah, bh) {
               0 => 0,
               _ => canon_classes_eq(arest, brest),
@@ -734,16 +734,16 @@ def canonicalCheck := ⟦
   }
 
   fn canon_g_list_eq(xs: List‹G›, ys: List‹G›) -> G {
-    match load(xs) {
-      ListNode.Nil =>
-        match load(ys) {
-          ListNode.Nil => 1,
+    match xs {
+      List.Nil =>
+        match ys {
+          List.Nil => 1,
           _ => 0,
         },
-      ListNode.Cons(x, xt) =>
-        match load(ys) {
-          ListNode.Nil => 0,
-          ListNode.Cons(y, yt) =>
+      List.Cons(__cell19) => let (x, xt) = load(__cell19);
+        match ys {
+          List.Nil => 0,
+          List.Cons(__cell20) => let (y, yt) = load(__cell20);
             match x - y {
               0 => canon_g_list_eq(xt, yt),
               _ => 0,
@@ -753,17 +753,17 @@ def canonicalCheck := ⟦
   }
 
   fn canon_flatten(classes: List‹List‹G››) -> List‹G› {
-    match load(classes) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(c, rest) =>
+    match classes {
+      List.Nil => List.Nil,
+      List.Cons(__cell21) => let (c, rest) = load(__cell21);
         list_concat(c, canon_flatten(rest)),
     }
   }
 
   fn canon_all_singleton(classes: List‹List‹G››) -> G {
-    match load(classes) {
-      ListNode.Nil => 1,
-      ListNode.Cons(c, rest) =>
+    match classes {
+      List.Nil => 1,
+      List.Cons(__cell22) => let (c, rest) = load(__cell22);
         match list_length(c) {
           1 => canon_all_singleton(rest),
           _ => 0,
@@ -775,12 +775,12 @@ def canonicalCheck := ⟦
   -- filter_indc_positions / Rust ingress.rs:2025-2048 — canonical
   -- order is validated for the Indc subset only).
   fn canon_indc_positions(members: List‹MutConst›, pos: G) -> List‹G› {
-    match load(members) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(m, rest) =>
+    match members {
+      List.Nil => List.Nil,
+      List.Cons(__cell23) => let (m, rest) = load(__cell23);
         let tail = canon_indc_positions(rest, pos + 1);
         match m {
-          MutConst.Indc(_) => store(ListNode.Cons(pos, tail)),
+          MutConst.Indc(_) => List.Cons(store((pos, tail))),
           _ => tail,
         },
     }
@@ -790,9 +790,9 @@ def canonicalCheck := ⟦
   -- `want_defn = 1` asks about Defn members, `want_defn = 0` about Indc.
   -- Recr members answer neither.
   fn canon_muts_has_kind(members: List‹MutConst›, want_defn: G) -> G {
-    match load(members) {
-      ListNode.Nil => 0,
-      ListNode.Cons(m, rest) =>
+    match members {
+      List.Nil => 0,
+      List.Cons(__cell24) => let (m, rest) = load(__cell24);
         let hit = match m {
           MutConst.Defn(_) => want_defn,
           MutConst.Indc(_) => 1 - want_defn,
diff --git a/Ix/IxVM/Kernel/Check.lean b/Ix/IxVM/Kernel/Check.lean
index bd04d62e..64f2c17c 100644
--- a/Ix/IxVM/Kernel/Check.lean
+++ b/Ix/IxVM/Kernel/Check.lean
@@ -114,9 +114,9 @@ def check := ⟦
   }
 
   fn validate_univ_params_list(lvls: List‹KLevel›, bound: G) {
-    match load(lvls) {
-      ListNode.Nil => (),
-      ListNode.Cons(u, rest) =>
+    match lvls {
+      List.Nil => (),
+      List.Cons(__cell1) => let (u, rest) = load(__cell1);
         validate_univ_params_seen(u, bound);
         validate_univ_params_list(rest, bound),
     }
@@ -311,8 +311,8 @@ def check := ⟦
           "more universe levels than the inductive declares");
         (),
       _ =>
-        match load(lvls) {
-          ListNode.Cons(l, rest) =>
+        match lvls {
+          List.Cons(__cell2) => let (l, rest) = load(__cell2);
             match load(l) {
               KLevelNode.Param(i) =>
                 assert_eq!(i, idx,
@@ -334,8 +334,8 @@ def check := ⟦
     match n_params - i {
       0 => (),
       _ =>
-        match load(args) {
-          ListNode.Cons(arg, rest) =>
+        match args {
+          List.Cons(__cell3) => let (arg, rest) = load(__cell3);
             match load(arg) {
               KExprNode.BVar(j) =>
                 assert_eq!(j, ((n_fields + n_params) - 1) - i,
@@ -403,8 +403,8 @@ def check := ⟦
             -- with zero fields has none, so this is the only gate that
             -- sees it. Mirror Inductive.lean:52-56.
             let idx_args = list_drop(args, n_params);
-            let block_addrs = store(ListNode.Cons(block_addr,
-                                                   store(ListNode.Nil)));
+            let block_addrs = List.Cons(store((block_addr,
+                                                   List.Nil)));
             assert_eq!(list_any_mentions_block(idx_args, block_addrs), 0,
               "ctor return type: reflexive occurrence in an index argument");
             (),
@@ -424,7 +424,7 @@ def check := ⟦
                 let eq = k_is_def_eq(da, db, types);
                 assert_eq!(eq, 1,
                   "ctor parameter type disagrees with the inductive's");
-                let inner = store(ListNode.Cons(da, types));
+                let inner = List.Cons(store((da, types)));
                 check_param_agreement_go(ba, bb, n - 1, inner),
             },
         },
@@ -434,7 +434,7 @@ def check := ⟦
   -- Walk first n Foralls of both types asserting domain def-eq under the
   -- accumulated param-binder context.
   fn check_param_agreement(ta: KExpr, tb: KExpr, n: G) {
-    check_param_agreement_go(ta, tb, n, store(ListNode.Nil))
+    check_param_agreement_go(ta, tb, n, List.Nil)
   }
 
   -- Peel n (params + indices) Foralls; body must be Srt(l). Returns l.
@@ -451,7 +451,7 @@ def check := ⟦
         match load(w) {
           KExprNode.Forall(dom, body) =>
             get_result_sort_level(body, n - 1,
-              store(ListNode.Cons(dom, types))),
+              List.Cons(store((dom, types)))),
         },
     }
   }
@@ -464,7 +464,7 @@ def check := ⟦
         assert_eq!(level_leq(dom_level, ind_level), 1,
           "ctor field lives in a universe above the inductive's");
         check_field_universes_inner(body, ind_level,
-          store(ListNode.Cons(dom, types))),
+          List.Cons(store((dom, types)))),
       _ => (),
     }
   }
@@ -478,7 +478,7 @@ def check := ⟦
         match load(ctor_ty) {
           KExprNode.Forall(dom, body) =>
             check_field_universes_skip_params(body, n_params - 1,
-              ind_level, store(ListNode.Cons(dom, types))),
+              ind_level, List.Cons(store((dom, types)))),
         },
     }
   }
@@ -489,7 +489,7 @@ def check := ⟦
     match load(ind_level) {
       KLevelNode.Zero => (),
       _ => check_field_universes_skip_params(ctor_ty, n_params,
-                                                  ind_level, store(ListNode.Nil)),
+                                                  ind_level, List.Nil),
     }
   }
 
@@ -518,9 +518,9 @@ def check := ⟦
   -- ============================================================================
 
   fn addr_list_contains(xs: List‹Addr›, target: Addr) -> G {
-    match load(xs) {
-      ListNode.Nil => 0,
-      ListNode.Cons(a, rest) =>
+    match xs {
+      List.Nil => 0,
+      List.Cons(__cell4) => let (a, rest) = load(__cell4);
         match address_eq(a, target) {
           1 => 1,
           _ => addr_list_contains(rest, target),
@@ -576,9 +576,9 @@ def check := ⟦
 
   fn list_any_mentions_block(es: List‹KExpr›,
                                   block_addrs: List‹Addr›) -> G {
-    match load(es) {
-      ListNode.Nil => 0,
-      ListNode.Cons(e, rest) =>
+    match es {
+      List.Nil => 0,
+      List.Cons(__cell5) => let (e, rest) = load(__cell5);
         match expr_mentions_block(e, block_addrs) {
           1 => 1,
           _ => list_any_mentions_block(rest, block_addrs),
@@ -595,7 +595,7 @@ def check := ⟦
       _ =>
         match load(e) {
           KExprNode.Forall(dom, body) =>
-            let t2 = store(ListNode.Cons(dom, types));
+            let t2 = List.Cons(store((dom, types)));
             peel_n_foralls_with_types(body, n - 1, t2),
           _ => (e, types),
         },
@@ -620,8 +620,8 @@ def check := ⟦
     match n_params - i {
       0 => (),
       _ =>
-        match load(args) {
-          ListNode.Cons(arg, rest) =>
+        match args {
+          List.Cons(__cell6) => let (arg, rest) = load(__cell6);
             match load(arg) {
               KExprNode.BVar(j) =>
                 assert_eq!(j, (depth - 1) - i,
@@ -683,7 +683,7 @@ def check := ⟦
           KExprNode.Forall(idom, ibody) =>
             assert_eq!(expr_mentions_block(idom, block_addrs), 0,
               "strict positivity: block occurs left of an arrow");
-            let t2 = store(ListNode.Cons(idom, types));
+            let t2 = List.Cons(store((idom, types)));
             check_positivity_aug(ibody, block_addrs, t2, check_params),
           _ =>
             match collect_spine(dom_w) {
@@ -720,8 +720,8 @@ def check := ⟦
                             -- mentioning an already-tracked block hits the
                             -- `caddr_is_peer` arm above and stops, and the
                             -- number of distinct reachable blocks is finite.
-                            let aug = store(ListNode.Cons(ext_block_addr,
-                                                              block_addrs));
+                            let aug = List.Cons(store((ext_block_addr,
+                                                              block_addrs)));
                             let rev_params = list_reverse(
                               list_take(args, n_ctor_params));
                             check_nested_ctors_positivity(ext_block_addr,
@@ -767,13 +767,13 @@ def check := ⟦
         match ctor_ci {
           KConstantInfo.Ctor(_, ctor_ty, _, _, _, _, _, _) =>
             match peel_n_foralls_with_types(ctor_ty, n_params,
-                                                 store(ListNode.Nil)) {
+                                                 List.Nil) {
               (body, _) =>
                 -- Parameters are substituted away, so the field walk
                 -- starts with no binders in scope — and with no
                 -- parameter binders to match, hence `check_params = 0`.
                 check_positivity_fields(expr_inst_many(body, rev_params, 0),
-                  aug, store(ListNode.Nil), 0);
+                  aug, List.Nil, 0);
                 check_nested_ctors_positivity(block_addr, ind_idx,
                   num_ctors, aug, cidx + 1, n_params, rev_params),
             },
@@ -786,7 +786,7 @@ def check := ⟦
     match load(ty) {
       KExprNode.Forall(dom, body) =>
         check_positivity_aug(dom, block_addrs, types, check_params);
-        let t2 = store(ListNode.Cons(dom, types));
+        let t2 = List.Cons(store((dom, types)));
         check_positivity_fields(body, block_addrs, t2, check_params),
       _ => (),
     }
@@ -800,7 +800,7 @@ def check := ⟦
   -- handled by augment_block_idxs walking ctor bodies recursively.
   fn check_positivity(ctor_ty: KExpr, n_params: G,
                           block_addr: Addr, types: List‹KExpr›) {
-    let block_addrs = store(ListNode.Cons(block_addr, store(ListNode.Nil)));
+    let block_addrs = List.Cons(store((block_addr, List.Nil)));
     match peel_n_foralls_with_types(ctor_ty, n_params, types) {
       (body, types_after) =>
         check_positivity_fields(body, block_addrs, types_after, 1),
@@ -825,7 +825,7 @@ def check := ⟦
                                 num_ctors: G, num_lvls: G,
                                 block_addr: Addr, ind_idx: G) {
     let ind_level = get_result_sort_level(ty, n_params + n_indices,
-                                               store(ListNode.Nil));
+                                               List.Nil);
     check_inductive_shape_ctors(ty, n_params, n_indices, num_ctors,
                                      num_lvls, block_addr, ind_idx,
                                      ind_level, 0)
@@ -857,7 +857,7 @@ def check := ⟦
             check_ctor_return_type(cty, c_np, n_indices, c_nf, num_lvls,
                                         block_addr, ind_idx);
             check_field_universes(cty, c_np, ind_level);
-            check_positivity(cty, c_np, block_addr, store(ListNode.Nil));
+            check_positivity(cty, c_np, block_addr, List.Nil);
             check_inductive_shape_ctors(ind_ty, n_params, n_indices,
                                              num_ctors, num_lvls,
                                              block_addr, ind_idx,
@@ -912,9 +912,9 @@ def check := ⟦
   fn peer_agree_walk(members: List‹MutConst›, self_ty: KExpr,
                           self_np: G, self_ni: G,
                           self_ind_idx: G, pos: G, block_addr: Addr) {
-    match load(members) {
-      ListNode.Nil => (),
-      ListNode.Cons(m, rest) =>
+    match members {
+      List.Nil => (),
+      List.Cons(__cell7) => let (m, rest) = load(__cell7);
         match m {
           MutConst.Indc(_) =>
             let is_self = eq_zero(pos - self_ind_idx);
@@ -931,9 +931,9 @@ def check := ⟦
                       "mutual block peers disagree on parameter count");
                     check_param_agreement(self_ty, peer_ty, self_np);
                     let self_lvl = get_result_sort_level(self_ty,
-                      self_np + self_ni, store(ListNode.Nil));
+                      self_np + self_ni, List.Nil);
                     let peer_lvl = get_result_sort_level(peer_ty,
-                      peer_np + peer_ni, store(ListNode.Nil));
+                      peer_np + peer_ni, List.Nil);
                     assert_eq!(level_equal(self_lvl, peer_lvl), 1,
                       "mutual block peers land in different universes");
                     peer_agree_walk(rest, self_ty, self_np, self_ni,
@@ -976,7 +976,7 @@ def check := ⟦
                           0 => 1,
                           _ => check_large_prop_ctor(ctor_ty, n_params,
                                                           n_fields,
-                                                          store(ListNode.Nil)),
+                                                          List.Nil),
                         },
                       _ => 0,
                     },
@@ -998,11 +998,11 @@ def check := ⟦
     match n_params {
       0 =>
         check_large_walk_fields(ty, n_fields, 0, types,
-                                     store(ListNode.Nil)),
+                                     List.Nil),
       _ =>
         match load(ty) {
           KExprNode.Forall(dom, body) =>
-            let inner = store(ListNode.Cons(dom, types));
+            let inner = List.Cons(store((dom, types)));
             check_large_prop_ctor(body, n_params - 1, n_fields, inner),
           _ => 0,
         },
@@ -1035,9 +1035,9 @@ def check := ⟦
             let bvar_idx = (n_fields - 1) - field_idx;
             let new_bvars = match is_data {
               0 => data_bvars,
-              _ => store(ListNode.Cons(bvar_idx, data_bvars)),
+              _ => List.Cons(store((bvar_idx, data_bvars))),
             };
-            let inner = store(ListNode.Cons(dom, types));
+            let inner = List.Cons(store((dom, types)));
             check_large_walk_fields(body, n_fields, field_idx + 1,
                                           inner, new_bvars),
           _ => 0,
@@ -1048,9 +1048,9 @@ def check := ⟦
   -- Returns 1 iff every BVar idx in `bvars` appears in `args` (as a syntactic
   -- BVar at the ret-binder depth).
   fn all_bvars_in_args(bvars: List‹G›, args: List‹KExpr›) -> G {
-    match load(bvars) {
-      ListNode.Nil => 1,
-      ListNode.Cons(b, rest) =>
+    match bvars {
+      List.Nil => 1,
+      List.Cons(__cell8) => let (b, rest) = load(__cell8);
         match args_contain_bvar(args, b) {
           0 => 0,
           _ => all_bvars_in_args(rest, args),
@@ -1060,9 +1060,9 @@ def check := ⟦
 
   -- Returns 1 if any element of `args` is syntactically `BVar(target)`.
   fn args_contain_bvar(args: List‹KExpr›, target: G) -> G {
-    match load(args) {
-      ListNode.Nil => 0,
-      ListNode.Cons(a, rest) =>
+    match args {
+      List.Nil => 0,
+      List.Cons(__cell9) => let (a, rest) = load(__cell9);
         match load(a) {
           KExprNode.BVar(i) =>
             match i - target {
@@ -1090,7 +1090,7 @@ def check := ⟦
           0 => 0,
           _ =>
             let result_level = get_result_sort_level(ind_ty,
-              n_params + n_indices, store(ListNode.Nil));
+              n_params + n_indices, List.Nil);
             match level_equal(result_level, store(KLevelNode.Zero)) {
               0 => 0,
               _ =>
@@ -1140,13 +1140,13 @@ def check := ⟦
   }
 
   fn muts_indc_count_is_one(members: List‹MutConst›, count: G) -> G {
-    match load(members) {
-      ListNode.Nil =>
+    match members {
+      List.Nil =>
         match count {
           1 => 1,
           _ => 0,
         },
-      ListNode.Cons(m, rest) =>
+      List.Cons(__cell10) => let (m, rest) = load(__cell10);
         match m {
           MutConst.Indc(_) => muts_indc_count_is_one(rest, count + 1),
           _ => muts_indc_count_is_one(rest, count),
@@ -1210,12 +1210,12 @@ def check := ⟦
               (head, _) =>
                 match load(head) {
                   KExprNode.Const(_, us) => us,
-                  _ => store(ListNode.Nil),
+                  _ => List.Nil,
                 },
             },
-          _ => store(ListNode.Nil),
+          _ => List.Nil,
         },
-      _ => store(ListNode.Nil),
+      _ => List.Nil,
     }
   }
 
@@ -1223,9 +1223,9 @@ def check := ⟦
   -- assumes that shape; a concrete occurrence may legitimately carry Succ or
   -- Max levels, and those must not be fed into it.
   fn lvls_all_params(us: List‹KLevel›) -> G {
-    match load(us) {
-      ListNode.Nil => 1,
-      ListNode.Cons(u, rest) =>
+    match us {
+      List.Nil => 1,
+      List.Cons(__cell11) => let (u, rest) = load(__cell11);
         match load(u) {
           KLevelNode.Param(_) => lvls_all_params(rest),
           _ => 0,
@@ -1261,13 +1261,13 @@ def check := ⟦
   -- arg that references a motive, minor, or index binder has no image in
   -- the param frame, and expr_lower would silently capture it.
   fn spec_params_lower(sps: List‹KExpr›, d: G) -> List‹KExpr› {
-    match load(sps) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(sp, rest) =>
+    match sps {
+      List.Nil => List.Nil,
+      List.Cons(__cell12) => let (sp, rest) = load(__cell12);
         assert_eq!(has_bvar_in_range(sp, 0, d), 0,
           "nested occurrence's parameter references a motive, minor, or index binder");
-        store(ListNode.Cons(expr_lower(sp, d, 0),
-                            spec_params_lower(rest, d))),
+        List.Cons(store((expr_lower(sp, d, 0),
+                            spec_params_lower(rest, d)))),
     }
   }
 
@@ -1299,11 +1299,11 @@ def check := ⟦
   -- Build param-lvls range: [Param(start), Param(start+1), ..., Param(start+count-1)].
   fn build_param_lvls_range(start: G, count: G, i: G) -> List‹KLevel› {
     match count - i {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ =>
-        store(ListNode.Cons(
+        List.Cons(store((
           store(KLevelNode.Param(start + i)),
-          build_param_lvls_range(start, count, i + 1))),
+          build_param_lvls_range(start, count, i + 1)))),
     }
   }
 
@@ -1325,10 +1325,10 @@ def check := ⟦
             match ci {
               KConstantInfo.Induct(nlvls, _, _, _, _, _, _, _) =>
                 let occ = build_param_lvls_range(univ_offset, nlvls, 0);
-                store(ListNode.Cons(
-                  (block_addr, 0, store(ListNode.Nil), occ),
-                  store(ListNode.Nil))),
-              _ => store(ListNode.Nil),
+                List.Cons(store((
+                  (block_addr, 0, List.Nil, occ),
+                  List.Nil))),
+              _ => List.Nil,
             },
         },
     }
@@ -1338,9 +1338,9 @@ def check := ⟦
                               cur: List‹MutConst›, block_addr: Addr,
                               univ_offset: G, pos: G)
                               -> List‹(Addr, G, List‹KExpr›, List‹KLevel›)› {
-    match load(cur) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(m, rest) =>
+    match cur {
+      List.Nil => List.Nil,
+      List.Cons(__cell13) => let (m, rest) = load(__cell13);
         match m {
           MutConst.Indc(_) =>
             let member_addr = projection_addr(all_members, block_addr, pos);
@@ -1350,10 +1350,10 @@ def check := ⟦
               _ => 0,
             };
             let occ = build_param_lvls_range(univ_offset, nlvls, 0);
-            store(ListNode.Cons(
-              (member_addr, 0, store(ListNode.Nil), occ),
+            List.Cons(store((
+              (member_addr, 0, List.Nil, occ),
               flat_originals_walk(all_members, rest, block_addr,
-                univ_offset, pos + 1))),
+                univ_offset, pos + 1)))),
           _ =>
             flat_originals_walk(all_members, rest, block_addr,
               univ_offset, pos + 1),
@@ -1376,7 +1376,7 @@ def check := ⟦
           ConstantInfo.Muts(members) =>
             aux_from_recrs_walk(members, members, block_addr,
               univ_offset, originals, 0),
-          _ => store(ListNode.Nil),
+          _ => List.Nil,
         },
     }
   }
@@ -1385,9 +1385,9 @@ def check := ⟦
   fn aux_already_in(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
                           target_addr: Addr,
                           target_sp: List‹KExpr›) -> G {
-    match load(flat) {
-      ListNode.Nil => 0,
-      ListNode.Cons(m, rest) =>
+    match flat {
+      List.Nil => 0,
+      List.Cons(__cell14) => let (m, rest) = load(__cell14);
         match m {
           (addr, is_aux, sp, _ou) =>
             match is_aux {
@@ -1502,16 +1502,16 @@ def check := ⟦
   }
 
   fn level_list_struct_eq(a: List‹KLevel›, b: List‹KLevel›) -> G {
-    match load(a) {
-      ListNode.Nil =>
-        match load(b) {
-          ListNode.Nil => 1,
+    match a {
+      List.Nil =>
+        match b {
+          List.Nil => 1,
           _ => 0,
         },
-      ListNode.Cons(x, xr) =>
-        match load(b) {
-          ListNode.Nil => 0,
-          ListNode.Cons(y, yr) =>
+      List.Cons(__cell15) => let (x, xr) = load(__cell15);
+        match b {
+          List.Nil => 0,
+          List.Cons(__cell16) => let (y, yr) = load(__cell16);
             match level_struct_eq(x, y) {
               1 => level_list_struct_eq(xr, yr),
               _ => 0,
@@ -1524,16 +1524,16 @@ def check := ⟦
   -- a flat position fail to match, changing the reconstruction. Structural
   -- compare, not raw pointer equality.
   fn spec_params_ptr_eq(a: List‹KExpr›, b: List‹KExpr›) -> G {
-    match load(a) {
-      ListNode.Nil =>
-        match load(b) {
-          ListNode.Nil => 1,
+    match a {
+      List.Nil =>
+        match b {
+          List.Nil => 1,
           _ => 0,
         },
-      ListNode.Cons(x, xr) =>
-        match load(b) {
-          ListNode.Nil => 0,
-          ListNode.Cons(y, yr) =>
+      List.Cons(__cell17) => let (x, xr) = load(__cell17);
+        match b {
+          List.Nil => 0,
+          List.Cons(__cell18) => let (y, yr) = load(__cell18);
             match kexpr_struct_eq(x, y) {
               1 => spec_params_ptr_eq(xr, yr),
               _ => 0,
@@ -1548,9 +1548,9 @@ def check := ⟦
                               acc: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
                               pos: G)
                               -> List‹(Addr, G, List‹KExpr›, List‹KLevel›)› {
-    match load(cur) {
-      ListNode.Nil => acc,
-      ListNode.Cons(m, rest) =>
+    match cur {
+      List.Nil => acc,
+      List.Cons(__cell19) => let (m, rest) = load(__cell19);
         match m {
           MutConst.Recr(_) =>
             let rec_wrapper = projection_addr(all_members, block_addr, pos);
@@ -1600,7 +1600,7 @@ def check := ⟦
     match rec_ci {
       KConstantInfo.Rec(_, ty, np, ni, nmot, nmin, _, _, _, _, _) =>
         extract_aux_spec_params(ty, np, nmot, nmin, ni, ext_np),
-      _ => store(ListNode.Nil),
+      _ => List.Nil,
     }
   }
 
@@ -1640,9 +1640,9 @@ def check := ⟦
   fn first_recr_parent_block(all_members: List‹MutConst›,
                                   cur: List‹MutConst›, block_addr: Addr,
                                   pos: G, fallback: Addr) -> Addr {
-    match load(cur) {
-      ListNode.Nil => fallback,
-      ListNode.Cons(m, rest) =>
+    match cur {
+      List.Nil => fallback,
+      List.Cons(__cell20) => let (m, rest) = load(__cell20);
         match m {
           MutConst.Recr(_) =>
             let wrapper = projection_addr(all_members, block_addr, pos);
@@ -1720,9 +1720,9 @@ def check := ⟦
                                   acc: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
                                   pos: G)
                                  -> List‹(Addr, G, List‹KExpr›, List‹KLevel›)› {
-    match load(cur) {
-      ListNode.Nil => acc,
-      ListNode.Cons(m, rest) =>
+    match cur {
+      List.Nil => acc,
+      List.Cons(__cell21) => let (m, rest) = load(__cell21);
         match m {
           MutConst.Recr(_) =>
             let rec_wrapper = projection_addr(all_members, rec_block_addr, pos);
@@ -1772,9 +1772,9 @@ def check := ⟦
   -- For aux target: matches aux's target ext addr.
   fn flat_find_pos(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
                         target_addr: Addr, pos: G) -> (G, G) {
-    match load(flat) {
-      ListNode.Nil => (0, 0),
-      ListNode.Cons(m, rest) =>
+    match flat {
+      List.Nil => (0, 0),
+      List.Cons(__cell22) => let (m, rest) = load(__cell22);
         match m {
           (member_addr, _is_aux, _sp, _ou) =>
             match address_eq(member_addr, target_addr) {
@@ -1792,9 +1792,9 @@ def check := ⟦
                              want_aux: G,
                              want_sp: List‹KExpr›,
                              pos: G) -> (G, G) {
-    match load(flat) {
-      ListNode.Nil => (0, 0),
-      ListNode.Cons(m, rest) =>
+    match flat {
+      List.Nil => (0, 0),
+      List.Cons(__cell23) => let (m, rest) = load(__cell23);
         match m {
           (member_addr, is_aux, sp, _ou) =>
             let addr_match = address_eq(member_addr, target_addr);
@@ -1818,10 +1818,10 @@ def check := ⟦
   -- Get member at position (returns (addr, is_aux, spec_params, occ_us)).
   fn flat_member_at(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
                          pos: G) -> (Addr, G, List‹KExpr›, List‹KLevel›) {
-    match load(flat) {
-      ListNode.Nil => (store([0u8; 32]), 0, store(ListNode.Nil),
-                       store(ListNode.Nil)),
-      ListNode.Cons(m, rest) =>
+    match flat {
+      List.Nil => (store([0u8; 32]), 0, List.Nil,
+                       List.Nil),
+      List.Cons(__cell24) => let (m, rest) = load(__cell24);
         match pos {
           0 => m,
           _ => flat_member_at(rest, pos - 1),
@@ -1892,16 +1892,16 @@ def check := ⟦
   -- binders than `n` is impossible for a block that passed validation.
   fn collect_index_doms(ty: KExpr, n: G) -> List‹KExpr› {
     match n {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ =>
         match load(ty) {
           KExprNode.Forall(dom, body) =>
-            store(ListNode.Cons(dom, collect_index_doms(body, n - 1))),
+            List.Cons(store((dom, collect_index_doms(body, n - 1)))),
           _ =>
-            match load(whnf(ty, store(ListNode.Nil))) {
+            match load(whnf(ty, List.Nil)) {
               KExprNode.Forall(dom, body) =>
-                store(ListNode.Cons(dom, collect_index_doms(body, n - 1))),
-              _ => store(ListNode.Nil),
+                List.Cons(store((dom, collect_index_doms(body, n - 1)))),
+              _ => List.Nil,
             },
         },
     }
@@ -1923,9 +1923,9 @@ def check := ⟦
 
   fn apply_spec_params_lifted(head: KExpr, spec_params: List‹KExpr›,
                                     depth: G) -> KExpr {
-    match load(spec_params) {
-      ListNode.Nil => head,
-      ListNode.Cons(sp, rest) =>
+    match spec_params {
+      List.Nil => head,
+      List.Cons(__cell25) => let (sp, rest) = load(__cell25);
         let lifted = expr_lift(sp, depth, 0);
         apply_spec_params_lifted(store(KExprNode.App(head, lifted)),
           rest, depth),
@@ -1958,9 +1958,9 @@ def check := ⟦
   -- Wrap body in foralls outside-in: doms = [d0, d1, ..., dM] →
   -- `forall (_ : d0), forall (_ : d1), ..., forall (_ : dM), body`.
   fn wrap_foralls(body: KExpr, doms: List‹KExpr›) -> KExpr {
-    match load(doms) {
-      ListNode.Nil => body,
-      ListNode.Cons(dom, rest) =>
+    match doms {
+      List.Nil => body,
+      List.Cons(__cell26) => let (dom, rest) = load(__cell26);
         store(KExprNode.Forall(dom, wrap_foralls(body, rest))),
     }
   }
@@ -1972,7 +1972,7 @@ def check := ⟦
   -- telescope for the reconstruction to be compared against.
   fn collect_n_doms_whnf(ty: KExpr, n: G) -> (List‹KExpr›, KExpr) {
     match n {
-      0 => (store(ListNode.Nil), ty),
+      0 => (List.Nil, ty),
       _ =>
         -- Structural first, reduce only if that fails. These bodies carry
         -- loose BVars (the walk substitutes nothing and the context is
@@ -1982,19 +1982,19 @@ def check := ⟦
         match load(ty) {
           KExprNode.Forall(dom, body) =>
             match collect_n_doms_whnf(body, n - 1) {
-              (rest, after) => (store(ListNode.Cons(dom, rest)), after),
+              (rest, after) => (List.Cons(store((dom, rest))), after),
             },
           _ =>
-            match load(whnf(ty, store(ListNode.Nil))) {
+            match load(whnf(ty, List.Nil)) {
               KExprNode.Forall(dom, body) =>
                 match collect_n_doms_whnf(body, n - 1) {
-                  (rest, after) => (store(ListNode.Cons(dom, rest)), after),
+                  (rest, after) => (List.Cons(store((dom, rest))), after),
                 },
               -- Tolerant, matching both reference kernels: stop early rather
               -- than reject here. A short telescope yields a reconstruction
               -- that differs from the declared type, so the def-eq assert
               -- still rejects — with an accurate message instead of this one.
-              _ => (store(ListNode.Nil), ty),
+              _ => (List.Nil, ty),
             },
         },
     }
@@ -2004,11 +2004,11 @@ def check := ⟦
   -- telescope, so each must be lifted past them. Position `i` is already
   -- under the `i` index binders that precede it, hence the `i` cutoff.
   fn list_lift_indices(doms: List‹KExpr›, shift: G, i: G) -> List‹KExpr› {
-    match load(doms) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(d, rest) =>
-        store(ListNode.Cons(expr_lift(d, shift, i),
-                            list_lift_indices(rest, shift, i + 1))),
+    match doms {
+      List.Nil => List.Nil,
+      List.Cons(__cell27) => let (d, rest) = load(__cell27);
+        List.Cons(store((expr_lift(d, shift, i),
+                            list_lift_indices(rest, shift, i + 1)))),
     }
   }
 
@@ -2094,9 +2094,9 @@ def check := ⟦
   -- Wrap body in Lams outside-in: doms = [d0, d1, ..., dM] →
   -- `Lam d0. Lam d1. ... Lam dM. body`.
   fn wrap_lams(body: KExpr, doms: List‹KExpr›) -> KExpr {
-    match load(doms) {
-      ListNode.Nil => body,
-      ListNode.Cons(dom, rest) =>
+    match doms {
+      List.Nil => body,
+      List.Cons(__cell28) => let (dom, rest) = load(__cell28);
         store(KExprNode.Lam(dom, wrap_lams(body, rest))),
     }
   }
@@ -2209,7 +2209,7 @@ def check := ⟦
                   store(KLevelNode.Zero))), 0)),
             };
             let result_level = get_result_sort_level(pty, pnp + pni,
-              store(ListNode.Nil));
+              List.Nil);
             let univ_offset = is_large_eliminator(result_level,
               num_ctors, single_ctor_pair);
             let elim_level = match univ_offset {
@@ -2226,7 +2226,7 @@ def check := ⟦
               (1 - address_eq(rec_block_addr, parent_block_addr));
             let rec_spec_params = match rec_is_aux {
               1 => extract_aux_spec_params_from_rec(rec_ci, pnp),
-              _ => store(ListNode.Nil),
+              _ => List.Nil,
             };
             -- Locate this recursor's parent in the flat block.
             --
@@ -2295,7 +2295,7 @@ def check := ⟦
         -- fallback route through here, so neither can skip this.
         let canonical_ty = build_rec_type(pty, pnlvls, n_p, pni, elim_level,
           univ_offset, flat, flat_own_params, self_pos);
-        assert_eq!(k_is_def_eq(ty, canonical_ty, store(ListNode.Nil)), 1,
+        assert_eq!(k_is_def_eq(ty, canonical_ty, List.Nil), 1,
           "recursor's declared type is not def-eq to the canonical reconstruction");
         let self_ctors_offset = ctors_before_pos(flat, self_pos, 0);
         let canonical = populate_rules(num_ctors, self_ctors_offset,
@@ -2313,9 +2313,9 @@ def check := ⟦
     match cur_pos - target_pos {
       0 => 0,
       _ =>
-        match load(flat) {
-          ListNode.Nil => 0,
-          ListNode.Cons(m, rest) =>
+        match flat {
+          List.Nil => 0,
+          List.Cons(__cell29) => let (m, rest) = load(__cell29);
             match m {
               (addr, _, _, _) =>
                 let ci = load(get_ci(addr));
@@ -2342,7 +2342,7 @@ def check := ⟦
                           is_aux: G, spec_params: List‹KExpr›,
                           cidx: G) -> List‹KExpr› {
     match num_ctors - cidx {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ =>
         let ctor_ci = load(get_ci_cprj(block_addr, ind_idx, cidx));
         match ctor_ci {
@@ -2352,12 +2352,12 @@ def check := ⟦
               n_params, n_motives, n_minors, np, occurrence_us,
               rec_lvls_list, flat, peer_recs, flat_own_params,
               is_aux, spec_params);
-            store(ListNode.Cons(rhs,
+            List.Cons(store((rhs,
               populate_rules(num_ctors, self_ctors_offset, block_addr,
                 ind_idx, n_params, n_motives, n_minors, occurrence_us,
                 rec_lvls_list, flat, peer_recs, flat_own_params, is_aux,
-                spec_params, cidx + 1))),
-          _ => store(ListNode.Nil),
+                spec_params, cidx + 1)))),
+          _ => List.Nil,
         },
     }
   }
@@ -2368,9 +2368,9 @@ def check := ⟦
   fn compare_rules(stored: List‹KRecRule›, canonical: List‹KExpr›,
                         n_p: G, n_mot: G, n_min: G,
                         block_addr: Addr, ind_idx: G, num_ctors: G, pos: G) {
-    match load(stored) {
-      ListNode.Nil => (),
-      ListNode.Cons(r, rest) =>
+    match stored {
+      List.Nil => (),
+      List.Cons(__cell30) => let (r, rest) = load(__cell30);
         match r {
           KRecRule.Mk(cidx, nf, rhs) =>
             -- Pin the rule's own labels against the constructor it claims.
@@ -2398,12 +2398,12 @@ def check := ⟦
                   "recursor rule field count differs from the ctor's");
                 (),
             };
-            match load(canonical) {
-              ListNode.Nil => (),
-              ListNode.Cons(cbody, crest) =>
+            match canonical {
+              List.Nil => (),
+              List.Cons(__cell31) => let (cbody, crest) = load(__cell31);
                 let total = ((n_p + n_mot) + n_min) + nf;
                 match peel_n_lams_collect(rhs, total, 0,
-                        store(ListNode.Nil)) {
+                        List.Nil) {
                   (stored_body, peeled, _) =>
                     assert_eq!(peeled, total,
                       "recursor rule rhs has too few binders to peel");
@@ -2428,7 +2428,7 @@ def check := ⟦
                     -- needs to INFER a bound variable's type now runs out
                     -- of context and aborts, which is the safe direction.
                     assert_eq!(k_is_def_eq(stored_body, cbody,
-                        store(ListNode.Nil)), 1,
+                        List.Nil), 1,
                       "recursor rule rhs differs from canonical reconstruction");
                     (),
                 };
@@ -2449,9 +2449,9 @@ def check := ⟦
                           n_params: G, n_motives: G, n_minors: G,
                           n_fields: G, rec_lvls_list: List‹KLevel›,
                           k: G) -> KExpr {
-    match load(rec_indices) {
-      ListNode.Nil => head,
-      ListNode.Cons(field_idx, rest) =>
+    match rec_indices {
+      List.Nil => head,
+      List.Cons(__cell32) => let (field_idx, rest) = load(__cell32);
         let mem_idx = list_lookup_or_default(rec_member_idxs, k, 0);
         let target_rec = list_lookup_or_default(peer_recs, mem_idx,
           store([0u8; 32]));
@@ -2480,7 +2480,7 @@ def check := ⟦
             -- wrapper's arguments (`drop 1 [A, B] = [B]`) instead of the
             -- inductive's (`drop 1 [a] = []`), so the IH was applied to one
             -- argument too many.
-            match collect_spine(whnf(inner_body, store(ListNode.Nil))) {
+            match collect_spine(whnf(inner_body, List.Nil)) {
               (_dh, dargs) =>
                 let idx_args = list_drop(dargs, target_n_params);
                 let with_idx = apply_spine_expr(with_minors, idx_args);
@@ -2525,8 +2525,8 @@ def check := ⟦
       n_own_params, 0, is_aux, spec_params, 0);
     -- spec_lift_by must name the same frame the spec_params are stored
     -- in; walk_fields_classify adds the walk depth itself.
-    match walk_fields_classify(after_params, flat, store(ListNode.Nil),
-            store(ListNode.Nil), store(ListNode.Nil), 0, 0) {
+    match walk_fields_classify(after_params, flat, List.Nil,
+            List.Nil, List.Nil, 0, 0) {
       (field_doms, rec_indices, rec_member_idxs, _ret_ty) =>
         let minor_var = (body_depth - 1) - ((n_params + n_motives) +
                                               ctor_minor_index);
@@ -2546,15 +2546,15 @@ def check := ⟦
   fn build_peer_recs(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
                           rec_block_addr: Addr,
                           rec_self_addr: Addr) -> List‹Addr› {
-    match load(flat) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(m, rest) =>
+    match flat {
+      List.Nil => List.Nil,
+      List.Cons(__cell33) => let (m, rest) = load(__cell33);
         match m {
           (member_addr, is_aux, sp, _ou) =>
             let peer = find_peer_recursor_with_spec(rec_block_addr,
               member_addr, sp, is_aux, rec_self_addr);
-            store(ListNode.Cons(peer,
-              build_peer_recs(rest, rec_block_addr, rec_self_addr))),
+            List.Cons(store((peer,
+              build_peer_recs(rest, rec_block_addr, rec_self_addr)))),
         },
     }
   }
@@ -2582,9 +2582,9 @@ def check := ⟦
                                    target_sp: List‹KExpr›,
                                    target_is_aux: G,
                                    rec_self_addr: Addr, pos: G) -> Addr {
-    match load(cur) {
-      ListNode.Nil => rec_self_addr,
-      ListNode.Cons(m, rest) =>
+    match cur {
+      List.Nil => rec_self_addr,
+      List.Cons(__cell34) => let (m, rest) = load(__cell34);
         match m {
           MutConst.Recr(_) =>
             let rec_wrapper = projection_addr(all_members, block_addr, pos);
@@ -2630,9 +2630,9 @@ def check := ⟦
   -- KCI). Used by build_ih_doms for target_n_params lookup.
   fn build_flat_own_params(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›)
                                   -> List‹G› {
-    match load(flat) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(m, rest) =>
+    match flat {
+      List.Nil => List.Nil,
+      List.Cons(__cell35) => let (m, rest) = load(__cell35);
         match m {
           (member_addr, _is_aux, _sp, _ou) =>
             let ci = load(get_ci(member_addr));
@@ -2640,8 +2640,8 @@ def check := ⟦
               KConstantInfo.Induct(_, _, n, _, _, _, _, _) => n,
               _ => 0,
             };
-            store(ListNode.Cons(np,
-              build_flat_own_params(rest))),
+            List.Cons(store((np,
+              build_flat_own_params(rest)))),
         },
     }
   }
@@ -2655,8 +2655,8 @@ def check := ⟦
     let info = ConstantInfo.CPrj(ConstructorProj.Mk(idx_u64, cidx_u64,
       block_addr));
     let proj_c = Constant.Mk(info,
-      store(ListNode.Nil), store(ListNode.Nil), store(ListNode.Nil));
-    let bytes = put_constant(proj_c, store(ListNode.Nil));
+      List.Nil, List.Nil, List.Nil);
+    let bytes = put_constant(proj_c, List.Nil);
     bytes_to_addr(bytes)
   }
 
@@ -2673,7 +2673,7 @@ def check := ⟦
                             num_ctors: G, prev_minors: G,
                             cidx: G) -> List‹KExpr› {
     match num_ctors - cidx {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ =>
         let ctor_ci = load(get_ci_cprj(block_addr, ind_idx, cidx));
         match ctor_ci {
@@ -2683,11 +2683,11 @@ def check := ⟦
               is_aux, spec_params, occurrence_us, flat, flat_own_params,
               n_rec_params, n_motives, prev_minors, motive_base,
               self_mem_idx);
-            store(ListNode.Cons(minor,
+            List.Cons(store((minor,
               build_minor_doms(member_addr, is_aux, spec_params,
                 occurrence_us, flat, flat_own_params, n_rec_params,
                 n_motives, motive_base, self_mem_idx, block_addr, ind_idx,
-                num_ctors, prev_minors + 1, cidx + 1))),
+                num_ctors, prev_minors + 1, cidx + 1)))),
           -- No tolerant arm on purpose. Returning Nil for a non-Ctor would
           -- yield a canonical type with FEWER minor premises than the
           -- inductive has constructors, and the declared type is
@@ -2719,9 +2719,9 @@ def check := ⟦
                                  n_rec_params: G, n_motives: G,
                                  motive_base: G, prev_minors: G,
                                  mem_pos: G) -> List‹KExpr› {
-    match load(flat) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(m, rest) =>
+    match flat {
+      List.Nil => List.Nil,
+      List.Cons(__cell36) => let (m, rest) = load(__cell36);
         match m {
           (member_addr, is_aux, spec_params, occ_us) =>
             let ci = load(get_ci(member_addr));
@@ -2794,7 +2794,7 @@ def check := ⟦
             peel_ctor_params_subst(body_substed, n - 1, depth,
               spec_lift, is_aux, spec_params, j + 1),
           _ =>
-            match load(whnf(ty, store(ListNode.Nil))) {
+            match load(whnf(ty, List.Nil)) {
               KExprNode.Forall(_, body) =>
                 let p = ctor_subst_param_for(j, depth, spec_lift, is_aux,
                   spec_params);
@@ -2822,8 +2822,8 @@ def check := ⟦
     let below_params = n_motives + prev_minors;
     let after_params = peel_ctor_params_subst(ctor_ty_inst, n_own_params,
       minor_saved, below_params, is_aux, spec_params, 0);
-    match walk_fields_classify(after_params, flat, store(ListNode.Nil),
-            store(ListNode.Nil), store(ListNode.Nil), 0, below_params) {
+    match walk_fields_classify(after_params, flat, List.Nil,
+            List.Nil, List.Nil, 0, below_params) {
       (field_doms, rec_indices, rec_member_idxs, ret_ty) =>
         let n_fields = list_length(field_doms);
         let n_ihs = list_length(rec_indices);
@@ -2854,7 +2854,7 @@ def check := ⟦
 
   -- Peel leading Foralls off `ty`, return (forall_doms, body).
   fn peel_leading_foralls(ty: KExpr) -> (List‹KExpr›, KExpr) {
-    let pair = peel_leading_foralls_acc(ty, store(ListNode.Nil));
+    let pair = peel_leading_foralls_acc(ty, List.Nil);
     match pair {
       (rev_acc, body) => (list_reverse(rev_acc), body),
     }
@@ -2864,7 +2864,7 @@ def check := ⟦
                                     -> (List‹KExpr›, KExpr) {
     match load(ty) {
       KExprNode.Forall(dom, body) =>
-        peel_leading_foralls_acc(body, store(ListNode.Cons(dom, acc))),
+        peel_leading_foralls_acc(body, List.Cons(store((dom, acc)))),
       _ => (acc, ty),
     }
   }
@@ -2886,9 +2886,9 @@ def check := ⟦
                         flat_own_params: List‹G›,
                         motive_base: G, n_fields: G, minor_saved: G,
                         k: G) -> List‹KExpr› {
-    match load(rec_indices) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(field_idx, rest) =>
+    match rec_indices {
+      List.Nil => List.Nil,
+      List.Cons(__cell37) => let (field_idx, rest) = load(__cell37);
         let mem_idx = list_lookup_or_default(rec_member_idxs, k, 0);
         let target_n_params = list_lookup_or_default(flat_own_params,
           mem_idx, 0);
@@ -2906,7 +2906,7 @@ def check := ⟦
             -- head, so its argument would be taken for an index and the
             -- induction hypothesis would apply the motive to one argument
             -- too many.
-            match collect_spine(whnf(inner_body, store(ListNode.Nil))) {
+            match collect_spine(whnf(inner_body, List.Nil)) {
               (_h, dom_args) =>
                 let idx_args = list_drop(dom_args, target_n_params);
                 let motive_ref = store(KExprNode.BVar(motive_bvar));
@@ -2915,10 +2915,10 @@ def check := ⟦
                 let field_app = build_apply_xs(field_ref, n_xs, 0);
                 let ih_body = store(KExprNode.App(with_indices, field_app));
                 let ih_dom = wrap_foralls(ih_body, forall_doms);
-                store(ListNode.Cons(ih_dom,
+                List.Cons(store((ih_dom,
                   build_ih_doms(rest, rec_member_idxs, field_doms,
                     flat_own_params, motive_base, n_fields, minor_saved,
-                    k + 1))),
+                    k + 1)))),
             },
         },
     }
@@ -2927,11 +2927,11 @@ def check := ⟦
   -- Lift each expr in a list by (shift, cutoff).
   fn list_lift_each(es: List‹KExpr›, shift: G, cutoff: G)
                           -> List‹KExpr› {
-    match load(es) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(e, rest) =>
-        store(ListNode.Cons(expr_lift(e, shift, cutoff),
-          list_lift_each(rest, shift, cutoff))),
+    match es {
+      List.Nil => List.Nil,
+      List.Cons(__cell38) => let (e, rest) = load(__cell38);
+        List.Cons(store((expr_lift(e, shift, cutoff),
+          list_lift_each(rest, shift, cutoff)))),
     }
   }
 
@@ -3002,7 +3002,7 @@ def check := ⟦
   -- below it, running the context cut off the end of the list.
   fn is_rec_field_peel(ty: KExpr, flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
                             spec_lift_by: G) -> (G, G) {
-    let w = whnf(ty, store(ListNode.Nil));
+    let w = whnf(ty, List.Nil);
     match load(w) {
       KExprNode.Forall(_, body) =>
         is_rec_field_peel(body, flat, spec_lift_by),
@@ -3030,9 +3030,9 @@ def check := ⟦
   fn flat_find_matching(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
                               caddr: Addr, dom_args: List‹KExpr›,
                               spec_lift_by: G, pos: G) -> (G, G) {
-    match load(flat) {
-      ListNode.Nil => (0, 0),
-      ListNode.Cons(m, rest) =>
+    match flat {
+      List.Nil => (0, 0),
+      List.Cons(__cell39) => let (m, rest) = load(__cell39);
         match m {
           (member_addr, is_aux, sp, _) =>
             let addr_match = address_eq(member_addr, caddr);
@@ -3058,12 +3058,12 @@ def check := ⟦
   fn spec_params_dom_prefix_match(sp: List‹KExpr›,
                                         args: List‹KExpr›,
                                         lift_by: G) -> G {
-    match load(sp) {
-      ListNode.Nil => 1,
-      ListNode.Cons(s, sr) =>
-        match load(args) {
-          ListNode.Nil => 0,
-          ListNode.Cons(a, ar) =>
+    match sp {
+      List.Nil => 1,
+      List.Cons(__cell40) => let (s, sr) = load(__cell40);
+        match args {
+          List.Nil => 0,
+          List.Cons(__cell41) => let (a, ar) = load(__cell41);
             let s_lifted = expr_lift(s, lift_by, 0);
             match kexpr_struct_eq(s_lifted, a) {
               1 => spec_params_dom_prefix_match(sr, ar, lift_by),
@@ -3092,11 +3092,11 @@ def check := ⟦
         -- field after the first fails to match its aux flat member and
         -- silently loses its induction hypothesis.
         let r = is_rec_field(dom, flat, spec_lift_by + fidx);
-        let new_doms = store(ListNode.Cons(dom, doms_acc));
+        let new_doms = List.Cons(store((dom, doms_acc)));
         match r {
           (1, mem_idx) =>
-            let new_rec = store(ListNode.Cons(fidx, rec_acc));
-            let new_mem = store(ListNode.Cons(mem_idx, rec_mem_acc));
+            let new_rec = List.Cons(store((fidx, rec_acc)));
+            let new_mem = List.Cons(store((mem_idx, rec_mem_acc)));
             walk_fields_classify(body, flat, new_doms, new_rec,
               new_mem, fidx + 1, spec_lift_by),
           _ =>
@@ -3111,9 +3111,9 @@ def check := ⟦
   fn build_all_motives_walk(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
                                   elim_level: KLevel, n_rec_params: G,
                                   j: G) -> List‹KExpr› {
-    match load(flat) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(m, rest) =>
+    match flat {
+      List.Nil => List.Nil,
+      List.Cons(__cell42) => let (m, rest) = load(__cell42);
         match m {
           (member_addr, is_aux, spec_params, occ_us) =>
             let ci = load(get_ci(member_addr));
@@ -3124,9 +3124,9 @@ def check := ⟦
                   m_own_params, m_n_indices, occ_us, elim_level,
                   n_rec_params, is_aux, spec_params);
                 let mt_lifted = expr_lift(mt, j, 0);
-                store(ListNode.Cons(mt_lifted,
+                List.Cons(store((mt_lifted,
                   build_all_motives_walk(rest, elim_level, n_rec_params,
-                    j + 1))),
+                    j + 1)))),
               _ =>
                 build_all_motives_walk(rest, elim_level, n_rec_params, j),
             },
@@ -3162,8 +3162,8 @@ def check := ⟦
                               rec_self_addr: Addr, rec_nlvls: G) -> KExpr {
     let base = canonical_norec_body(cidx, num_ctors, rec_np, nf);
     let body_depth = (rec_np + 1 + num_ctors) + nf;
-    let block_addrs = store(ListNode.Cons(rec_block_addr,
-      store(ListNode.Cons(parent_block_addr, store(ListNode.Nil)))));
+    let block_addrs = List.Cons(store((rec_block_addr,
+      List.Cons(store((parent_block_addr, List.Nil))))));
     let rec_infos = walk_fields_multi(ctor_body, block_addrs, 0);
     apply_ihs(base, rec_infos, rec_np, rec_ni, nf, body_depth,
       num_ctors, rec_block_addr, rec_self_addr, rec_nlvls)
@@ -3180,10 +3180,10 @@ def check := ⟦
         };
         let rest = walk_fields_multi(body, block_addrs, field_pos + 1);
         match is_direct_rec {
-          1 => store(ListNode.Cons((field_pos, dom), rest)),
+          1 => List.Cons(store(((field_pos, dom), rest))),
           _ => rest,
         },
-      _ => store(ListNode.Nil),
+      _ => List.Nil,
     }
   }
 
@@ -3285,7 +3285,7 @@ def check := ⟦
   fn ctor_has_rec_fields_solo(ctor_ty: KExpr, n_params: G,
                                     parent_addr: Addr) -> G {
     let after_params = peel_n_foralls_tolerant(ctor_ty, n_params);
-    let block_addrs = store(ListNode.Cons(parent_addr, store(ListNode.Nil)));
+    let block_addrs = List.Cons(store((parent_addr, List.Nil)));
     scan_fields_for_block_ref(after_params, block_addrs)
   }
 
@@ -3358,8 +3358,8 @@ def check := ⟦
                                         field_pos: G) -> List‹(G, KExpr)› {
     match load(ty) {
       KExprNode.Forall(dom, body) =>
-        let block_addrs = store(ListNode.Cons(block_addr,
-          store(ListNode.Nil)));
+        let block_addrs = List.Cons(store((block_addr,
+          List.Nil)));
         let mentions = expr_mentions_block(dom, block_addrs);
         let is_direct_rec = match mentions {
           0 => 0,
@@ -3368,10 +3368,10 @@ def check := ⟦
         let rest_infos = walk_fields_collect_rec_infos(body, block_addr,
           field_pos + 1);
         match is_direct_rec {
-          1 => store(ListNode.Cons((field_pos, dom), rest_infos)),
+          1 => List.Cons(store(((field_pos, dom), rest_infos))),
           _ => rest_infos,
         },
-      _ => store(ListNode.Nil),
+      _ => List.Nil,
     }
   }
 
@@ -3387,9 +3387,9 @@ def check := ⟦
                     n_p: G, n_i: G, nf: G, body_depth: G,
                     num_ctors: G, block_addr: Addr,
                     rec_self_addr: Addr, rec_nlvls: G) -> KExpr {
-    match load(rec_infos) {
-      ListNode.Nil => body,
-      ListNode.Cons(info, rest) =>
+    match rec_infos {
+      List.Nil => body,
+      List.Cons(__cell43) => let (info, rest) = load(__cell43);
         match info {
           (pos, dom) =>
             let ih = build_ih(pos, dom, n_p, n_i, nf, body_depth,
@@ -3456,9 +3456,9 @@ def check := ⟦
                              cur: List‹MutConst›, block_addr: Addr,
                              target_ind_addr: Addr, rec_self_addr: Addr,
                              pos: G) -> Addr {
-    match load(cur) {
-      ListNode.Nil => rec_self_addr,
-      ListNode.Cons(m, rest) =>
+    match cur {
+      List.Nil => rec_self_addr,
+      List.Cons(__cell44) => let (m, rest) = load(__cell44);
         match m {
           MutConst.Recr(_) =>
             -- Get this recursor's wrapper addr + KCI, parse ty for
@@ -3484,9 +3484,9 @@ def check := ⟦
   }
 
   fn apply_spine_expr(head: KExpr, args: List‹KExpr›) -> KExpr {
-    match load(args) {
-      ListNode.Nil => head,
-      ListNode.Cons(a, rest) =>
+    match args {
+      List.Nil => head,
+      List.Cons(__cell45) => let (a, rest) = load(__cell45);
         apply_spine_expr(store(KExprNode.App(head, a)), rest),
     }
   }
@@ -3505,8 +3505,8 @@ def check := ⟦
                                   field_pos: G) -> List‹G› {
     match load(ty) {
       KExprNode.Forall(dom, body) =>
-        let block_addrs = store(ListNode.Cons(block_addr,
-          store(ListNode.Nil)));
+        let block_addrs = List.Cons(store((block_addr,
+          List.Nil)));
         let mentions = expr_mentions_block(dom, block_addrs);
         let is_direct_rec = match mentions {
           0 => 0,
@@ -3515,10 +3515,10 @@ def check := ⟦
         let rest_positions = walk_fields_collect_rec(body, block_addr,
           field_pos + 1);
         match is_direct_rec {
-          1 => store(ListNode.Cons(field_pos, rest_positions)),
+          1 => List.Cons(store((field_pos, rest_positions))),
           _ => rest_positions,
         },
-      _ => store(ListNode.Nil),
+      _ => List.Nil,
     }
   }
 
@@ -3542,9 +3542,9 @@ def check := ⟦
                         n_p: G, n_i: G, nf: G, body_depth: G,
                         num_ctors: G, rec_self_addr: Addr,
                         rec_nlvls: G) -> KExpr {
-    match load(rec_positions) {
-      ListNode.Nil => body,
-      ListNode.Cons(pos, rest) =>
+    match rec_positions {
+      List.Nil => body,
+      List.Cons(__cell46) => let (pos, rest) = load(__cell46);
         let ih = build_ih_solo(pos, n_p, n_i, nf, body_depth,
           num_ctors, rec_self_addr, rec_nlvls);
         apply_ihs_solo(store(KExprNode.App(body, ih)), rest,
@@ -3588,11 +3588,11 @@ def check := ⟦
 
   fn build_rec_lvls_list(total: G, i: G) -> List‹KLevel› {
     match total - i {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ =>
-        store(ListNode.Cons(
+        List.Cons(store((
           store(KLevelNode.Param(i)),
-          build_rec_lvls_list(total, i + 1))),
+          build_rec_lvls_list(total, i + 1)))),
     }
   }
 
@@ -3618,9 +3618,9 @@ def check := ⟦
   -- outer_depth + rule.num_args (nf) and universe-bound nlvls.
   fn check_rec_rules_wellscoped(rules: List‹KRecRule›,
                                      outer_depth: G, nlvls: G) {
-    match load(rules) {
-      ListNode.Nil => (),
-      ListNode.Cons(r, rest) =>
+    match rules {
+      List.Nil => (),
+      List.Cons(__cell47) => let (r, rest) = load(__cell47);
         match r {
           KRecRule.Mk(_, nf, rhs) =>
             validate_expr_well_scoped(rhs, outer_depth + nf, nlvls);
@@ -3640,9 +3640,9 @@ def check := ⟦
                                 rec_np: G, rec_self_addr: Addr,
                                 rec_nlvls: G,
                                 rec_block_addr: Addr) {
-    match load(rules) {
-      ListNode.Nil => (),
-      ListNode.Cons(r, rest) =>
+    match rules {
+      List.Nil => (),
+      List.Cons(__cell48) => let (r, rest) = load(__cell48);
         match r {
           KRecRule.Mk(cidx, num_args, rhs) =>
             assert_eq!(cidx, expected_cidx,
@@ -3664,7 +3664,7 @@ def check := ⟦
                   rec_np, parent_ni, nf, aux_ctor_body, rec_block_addr,
                   parent_block_addr, rec_self_addr, rec_nlvls);
                 let types = build_dummy_types(total_lams,
-                  store(ListNode.Nil));
+                  List.Nil);
                 assert_eq!(k_is_def_eq(rhs_body, canonical, types), 1,
                   "aux recursor rule rhs differs from canonical reconstruction");
                 check_aux_rules_walk(rest, parent_block_addr,
@@ -3682,9 +3682,9 @@ def check := ⟦
                                ni: G, rec_self_addr: Addr,
                                rec_nlvls: G, is_aux: G,
                                rec_block_addr: Addr) {
-    match load(rules) {
-      ListNode.Nil => (),
-      ListNode.Cons(r, rest) =>
+    match rules {
+      List.Nil => (),
+      List.Cons(__cell49) => let (r, rest) = load(__cell49);
         match r {
           KRecRule.Mk(cidx, num_args, rhs) =>
             assert_eq!(cidx, expected_cidx,
@@ -3735,7 +3735,7 @@ def check := ⟦
         let canonical = canonical_body(cidx, num_ctors, np, ni, nf,
           ctor_ty, block_addr, rec_self_addr, rec_nlvls, rec_block_addr);
         let types = build_ctor_rule_types(ctor_ty, np, nf,
-          num_ctors, store(ListNode.Nil));
+          num_ctors, List.Nil);
         assert_eq!(k_is_def_eq(rhs_body, canonical, types), 1,
           "non-recursive ctor rule rhs differs from canonical reconstruction");
         (),
@@ -3752,8 +3752,8 @@ def check := ⟦
   fn scan_fields_for_complex(ty: KExpr, block_addr: Addr) -> G {
     match load(ty) {
       KExprNode.Forall(dom, body) =>
-        let block_addrs = store(ListNode.Cons(block_addr,
-          store(ListNode.Nil)));
+        let block_addrs = List.Cons(store((block_addr,
+          List.Nil)));
         let mentions = expr_mentions_block(dom, block_addrs);
         let is_complex = match mentions {
           0 => 0,
@@ -3841,7 +3841,7 @@ def check := ⟦
         match load(e) {
           KExprNode.Lam(dom, body) =>
             peel_n_lams_collect(body, n - 1, peeled + 1,
-              store(ListNode.Cons(dom, acc))),
+              List.Cons(store((dom, acc)))),
           _ => (e, peeled, acc),
         },
     }
@@ -3859,7 +3859,7 @@ def check := ⟦
       0 => acc,
       _ =>
         let dummy = store(KExprNode.Srt(store(KLevelNode.Zero)));
-        build_dummy_types(n - 1, store(ListNode.Cons(dummy, acc))),
+        build_dummy_types(n - 1, List.Cons(store((dummy, acc)))),
     }
   }
 
@@ -3869,40 +3869,40 @@ def check := ⟦
     match ci {
       KConstantInfo.Axiom(nlvls, ty, _) =>
         validate_expr_well_scoped(ty, 0, nlvls);
-        k_ensure_sort(ty, store(ListNode.Nil));
+        k_ensure_sort(ty, List.Nil);
         assert_safety(u, ty),
       KConstantInfo.Defn(nlvls, ty, val, _, _) =>
         validate_expr_well_scoped(ty, 0, nlvls);
         validate_expr_well_scoped(val, 0, nlvls);
-        k_ensure_sort(ty, store(ListNode.Nil));
+        k_ensure_sort(ty, List.Nil);
         assert_safety(u, ty);
         assert_safety(u, val);
-        k_check(val, ty, store(ListNode.Nil)),
+        k_check(val, ty, List.Nil),
       KConstantInfo.Thm(nlvls, ty, val) =>
         validate_expr_well_scoped(ty, 0, nlvls);
         validate_expr_well_scoped(val, 0, nlvls);
-        let lvl = k_ensure_sort(ty, store(ListNode.Nil));
+        let lvl = k_ensure_sort(ty, List.Nil);
         assert_eq!(level_equal(lvl, store(KLevelNode.Zero)), 1,
           "theorem's type is not a Prop");
         assert_safety(u, ty);
         assert_safety(u, val);
-        k_check(val, ty, store(ListNode.Nil)),
+        k_check(val, ty, List.Nil),
       KConstantInfo.Opaque(nlvls, ty, val, _) =>
         validate_expr_well_scoped(ty, 0, nlvls);
         validate_expr_well_scoped(val, 0, nlvls);
-        k_ensure_sort(ty, store(ListNode.Nil));
+        k_ensure_sort(ty, List.Nil);
         assert_safety(u, ty);
         assert_safety(u, val);
-        k_check(val, ty, store(ListNode.Nil)),
+        k_check(val, ty, List.Nil),
       KConstantInfo.Quot(nlvls, ty, kind) =>
         validate_expr_well_scoped(ty, 0, nlvls);
-        k_ensure_sort(ty, store(ListNode.Nil));
+        k_ensure_sort(ty, List.Nil);
         assert_safety(u, ty);
         check_quot(addr, kind, nlvls, ty),
       KConstantInfo.Induct(nlvls, ty, n_params, n_indices, num_ctors,
                             _, ind_block, ind_idx) =>
         validate_expr_well_scoped(ty, 0, nlvls);
-        k_ensure_sort(ty, store(ListNode.Nil));
+        k_ensure_sort(ty, List.Nil);
         assert_safety(u, ty);
         -- Canonical block member ordering (adversarial threat model:
         -- reordered/alpha-colliding Muts members must be rejected).
@@ -3918,7 +3918,7 @@ def check := ⟦
       KConstantInfo.Ctor(nlvls, ty, block_addr, ind_idx, _cidx,
                          num_params, num_fields, _) =>
         validate_expr_well_scoped(ty, 0, nlvls);
-        k_ensure_sort(ty, store(ListNode.Nil));
+        k_ensure_sort(ty, List.Nil);
         assert_safety(u, ty);
         let ind_ci = load(@ctor_parent_ind_ci(block_addr, ind_idx));
         match ind_ci {
@@ -3931,14 +3931,14 @@ def check := ⟦
                                         num_fields, ind_nlvls, block_addr,
                                         ind_idx);
             let ind_level = get_result_sort_level(ind_ty,
-              ind_n_params + ind_n_indices, store(ListNode.Nil));
+              ind_n_params + ind_n_indices, List.Nil);
             check_field_universes(ty, num_params, ind_level);
             check_positivity(ty, num_params, block_addr,
-                                  store(ListNode.Nil)),
+                                  List.Nil),
         },
       KConstantInfo.Rec(nlvls, ty, _, _, _, _, _, _, _, rec_block, _) =>
         validate_expr_well_scoped(ty, 0, nlvls);
-        k_ensure_sort(ty, store(ListNode.Nil));
+        k_ensure_sort(ty, List.Nil);
         assert_safety(u, ty);
         check_canonical_block(rec_block);
         check_recursor_member(ci, addr),
diff --git a/Ix/IxVM/Kernel/Claim.lean b/Ix/IxVM/Kernel/Claim.lean
index 741c1efd..33af07a3 100644
--- a/Ix/IxVM/Kernel/Claim.lean
+++ b/Ix/IxVM/Kernel/Claim.lean
@@ -74,9 +74,9 @@ def claim := ⟦
       -- projection's block comes from the ConstantInfo payload, both
       -- walked separately.
       Expr.Ref(i, _) =>
-        store(ListNode.Cons(flatten_u64(i), store(ListNode.Nil))),
+        List.Cons(store((flatten_u64(i), List.Nil))),
       Expr.Prj(i, _, inner) =>
-        store(ListNode.Cons(flatten_u64(i), const_idxs_expr(inner))),
+        List.Cons(store((flatten_u64(i), const_idxs_expr(inner)))),
       Expr.App(f, a) => list_concat(const_idxs_expr(f), const_idxs_expr(a)),
       Expr.Lam(t, b) => list_concat(const_idxs_expr(t), const_idxs_expr(b)),
       Expr.All(t, b) => list_concat(const_idxs_expr(t), const_idxs_expr(b)),
@@ -87,22 +87,22 @@ def claim := ⟦
       -- following share edges expands it exponentially. Every shared
       -- subexpression is itself an entry in `sharing`, which is walked
       -- once below, so coverage is complete and the traversal stays linear.
-      _ => store(ListNode.Nil),
+      _ => List.Nil,
     }
   }
 
   fn const_idxs_exprs(es: List‹&Expr›) -> List‹G› {
-    match load(es) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(e, rest) =>
+    match es {
+      List.Nil => List.Nil,
+      List.Cons(__cell1) => let (e, rest) = load(__cell1);
         list_concat(const_idxs_expr(e), const_idxs_exprs(rest)),
     }
   }
 
   fn const_idxs_rules(rs: List‹RecursorRule›) -> List‹G› {
-    match load(rs) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(r, rest) =>
+    match rs {
+      List.Nil => List.Nil,
+      List.Cons(__cell2) => let (r, rest) = load(__cell2);
         match r {
           RecursorRule.Mk(_, rhs) =>
             list_concat(const_idxs_expr(rhs), const_idxs_rules(rest)),
@@ -111,9 +111,9 @@ def claim := ⟦
   }
 
   fn const_idxs_ctors(cs: List‹Constructor›) -> List‹G› {
-    match load(cs) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(c, rest) =>
+    match cs {
+      List.Nil => List.Nil,
+      List.Cons(__cell3) => let (c, rest) = load(__cell3);
         match c {
           Constructor.Mk(_, _, _, _, _, typ) =>
             list_concat(const_idxs_expr(typ), const_idxs_ctors(rest)),
@@ -122,9 +122,9 @@ def claim := ⟦
   }
 
   fn const_idxs_muts(ms: List‹MutConst›) -> List‹G› {
-    match load(ms) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(m, rest) =>
+    match ms {
+      List.Nil => List.Nil,
+      List.Cons(__cell4) => let (m, rest) = load(__cell4);
         match m {
           MutConst.Defn(d) =>
             match d {
@@ -187,9 +187,9 @@ def claim := ⟦
   }
 
   fn g_list_has(xs: List‹G›, x: G) -> G {
-    match load(xs) {
-      ListNode.Nil => 0,
-      ListNode.Cons(y, rest) =>
+    match xs {
+      List.Nil => 0,
+      List.Cons(__cell5) => let (y, rest) = load(__cell5);
         match y - x {
           0 => 1,
           _ => g_list_has(rest, x),
@@ -254,9 +254,9 @@ def claim := ⟦
   -- decision comes from `const_idxs_of`, i.e. from bytes already bound by
   -- blake3 — not from an IO probe the prover answers.
   fn walk_refs_transitive(refs: List‹Addr›, consts: List‹G›, i: G) {
-    match load(refs) {
-      ListNode.Nil => (),
-      ListNode.Cons(a, rest) =>
+    match refs {
+      List.Nil => (),
+      List.Cons(__cell6) => let (a, rest) = load(__cell6);
         match g_list_has(consts, i) {
           1 => run_check_transitive(a),
           _ => (),
@@ -270,9 +270,9 @@ def claim := ⟦
   -- members get their full soundness gauntlet.
   fn check_muts_all(block_addr: Addr, all_members: List‹MutConst›,
                           cur: List‹MutConst›, pos: G) {
-    match load(cur) {
-      ListNode.Nil => (),
-      ListNode.Cons(m, rest) =>
+    match cur {
+      List.Nil => (),
+      List.Cons(__cell7) => let (m, rest) = load(__cell7);
         check_muts_member_at(block_addr, all_members, m, pos);
         check_muts_all(block_addr, all_members, rest, pos + 1),
     }
@@ -294,14 +294,14 @@ def claim := ⟦
   -- the channel table in Ix/IxVM/ClaimHarness.lean.
   -- ============================================================================
   fn leaf_hash(addr: Addr) -> Addr {
-    let tail = put_address(addr, store(ListNode.Nil));
-    let bytes = store(ListNode.Cons(0u8, tail));
+    let tail = put_address(addr, List.Nil);
+    let bytes = List.Cons(store((0u8, tail)));
     bytes_to_addr(bytes)
   }
 
   fn node_hash(l: Addr, r: Addr) -> Addr {
-    let tail = put_address(l, put_address(r, store(ListNode.Nil)));
-    let bytes = store(ListNode.Cons(1u8, tail));
+    let tail = put_address(l, put_address(r, List.Nil));
+    let bytes = List.Cons(store((1u8, tail)));
     bytes_to_addr(bytes)
   }
 
@@ -313,9 +313,9 @@ def claim := ⟦
       0 =>
         let (addr, s2) = get_address(s);
         let h = leaf_hash(addr);
-        (h, store(ListNode.Cons(addr, store(ListNode.Nil))), s2),
+        (h, List.Cons(store((addr, List.Nil))), s2),
       1 =>
-        (store([0u8; 32]), store(ListNode.Nil), s),
+        (store([0u8; 32]), List.Nil, s),
       2 =>
         let (lh, ll, s2) = parse_atree_body(s);
         let (rh, rl, s3) = parse_atree_body(s2);
@@ -333,7 +333,7 @@ def claim := ⟦
     assert_eq!(flag, 0xE, "assumption tree: wrong tag4 flag");
     assert_eq!(to_field(size[0]), 2, "assumption tree: wrong tag4 variant");
     let (computed_root, leaves, rest) = parse_atree_body(s);
-    assert_eq!(load(rest), ListNode.Nil,
+    assert_eq!(rest, List.Nil,
       "assumption tree: trailing bytes after tree body");
     let computed_arr = load(computed_root);
     -- Binds ch 1 to its key: the recomputed merkle root must equal the
@@ -372,9 +372,9 @@ def claim := ⟦
   -- query vs the O(n) list scan — the frontier list is the biggest
   -- per-visit cost on fat-frontier shards (e.g. 1977 asm leaves).
   fn addr_set_build(leaves: List‹Addr›, acc: RBTreeMap‹G›) -> RBTreeMap‹G› {
-    match load(leaves) {
-      ListNode.Nil => acc,
-      ListNode.Cons(a, rest) =>
+    match leaves {
+      List.Nil => acc,
+      List.Cons(__cell8) => let (a, rest) = load(__cell8);
         addr_set_build(rest, rbtree_map_insert(ptr_val(a), 1, acc)),
     }
   }
@@ -443,9 +443,9 @@ def claim := ⟦
   fn env_walk_refs(refs: List‹Addr›, consts: List‹G›, i: G,
                        owned: RBTreeMap‹G›,
                        asm: RBTreeMap‹G›, strict: G) {
-    match load(refs) {
-      ListNode.Nil => (),
-      ListNode.Cons(a, rest) =>
+    match refs {
+      List.Nil => (),
+      List.Cons(__cell9) => let (a, rest) = load(__cell9);
         match g_list_has(consts, i) {
           1 => env_walk(a, owned, asm, strict),
           _ => (),
@@ -456,9 +456,9 @@ def claim := ⟦
 
   fn env_walk_leaves(leaves: List‹Addr›, owned: RBTreeMap‹G›,
                          asm: RBTreeMap‹G›) {
-    match load(leaves) {
-      ListNode.Nil => (),
-      ListNode.Cons(a, rest) =>
+    match leaves {
+      List.Nil => (),
+      List.Cons(__cell10) => let (a, rest) = load(__cell10);
         env_walk(a, owned, asm, 1);
         env_walk_leaves(rest, owned, asm),
     }
@@ -473,7 +473,7 @@ def claim := ⟦
   fn run_check_env(env_root: Addr, asm: Option‹Addr›) {
     let owned = load_assumption_tree(env_root);
     let asm_leaves = match asm {
-      Option.None => store(ListNode.Nil),
+      Option.None => List.Nil,
       Option.Some(r) => load_assumption_tree(r),
     };
     let owned_set = addr_set_build(owned, RBTreeMap.Nil);
@@ -623,11 +623,11 @@ def claim := ⟦
   fn get_reveal_rule_list_inner(stream: ByteStream, count: U64)
       -> (List‹RevealRecursorRule›, ByteStream) {
     match u64_is_zero(count) {
-      1 => (store(ListNode.Nil), stream),
+      1 => (List.Nil, stream),
       _ =>
         let (rule, s) = get_reveal_rule(stream);
         let (rest, s2) = get_reveal_rule_list_inner(s, relaxed_u64_pred(count));
-        (store(ListNode.Cons(rule, rest)), s2),
+        (List.Cons(store((rule, rest))), s2),
     }
   }
 
@@ -667,11 +667,11 @@ def claim := ⟦
   fn get_ctor_entry_list_inner(stream: ByteStream, count: U64)
       -> (List‹(U64, RevealConstructorInfo)›, ByteStream) {
     match u64_is_zero(count) {
-      1 => (store(ListNode.Nil), stream),
+      1 => (List.Nil, stream),
       _ =>
         let (entry, s) = get_ctor_entry(stream);
         let (rest, s2) = get_ctor_entry_list_inner(s, relaxed_u64_pred(count));
-        (store(ListNode.Cons(entry, rest)), s2),
+        (List.Cons(store((entry, rest))), s2),
     }
   }
 
@@ -737,11 +737,11 @@ def claim := ⟦
   fn get_mut_entry_list_inner(stream: ByteStream, count: U64)
       -> (List‹(U64, RevealMutConstInfo)›, ByteStream) {
     match u64_is_zero(count) {
-      1 => (store(ListNode.Nil), stream),
+      1 => (List.Nil, stream),
       _ =>
         let (entry, s) = get_mut_entry(stream);
         let (rest, s2) = get_mut_entry_list_inner(s, relaxed_u64_pred(count));
-        (store(ListNode.Cons(entry, rest)), s2),
+        (List.Cons(store((entry, rest))), s2),
     }
   }
 
@@ -802,7 +802,7 @@ def claim := ⟦
         (RevealConstantInfo.DPrj(idx, block), s),
       8 =>
         let (components, s) = match b0 {
-          0 => (store(ListNode.Nil), s),
+          0 => (List.Nil, s),
           1 =>
             let (count, s2) = get_tag0(s);
             get_mut_entry_list_inner(s2, count),
@@ -813,7 +813,7 @@ def claim := ⟦
 
   -- Content hash of an `Expr`: `blake3(put_expr expr)`.
   fn expr_addr(e_ref: &Expr) -> Addr {
-    let bytes = put_expr(load(e_ref), store(ListNode.Nil));
+    let bytes = put_expr(load(e_ref), List.Nil);
     bytes_to_addr(bytes)
   }
 
@@ -926,14 +926,14 @@ def claim := ⟦
   fn check_recr_rules(real: List‹RecursorRule›,
                       claimed: List‹RevealRecursorRule›,
                       pos: U64) {
-    match load(claimed) {
-      ListNode.Nil =>
-        match load(real) {
-          ListNode.Nil => (),
+    match claimed {
+      List.Nil =>
+        match real {
+          List.Nil => (),
         },
-      ListNode.Cons(cr, rest_claimed) =>
-        match load(real) {
-          ListNode.Cons(rr, rest_real) =>
+      List.Cons(__cell11) => let (cr, rest_claimed) = load(__cell11);
+        match real {
+          List.Cons(__cell12) => let (rr, rest_real) = load(__cell12);
             match cr {
               RevealRecursorRule.Mk(c_idx, c_fields, c_rhs) =>
                 match rr {
@@ -984,9 +984,9 @@ def claim := ⟦
 
   fn check_ctor_entries(real_list: List‹Constructor›,
                         claimed: List‹(U64, RevealConstructorInfo)›) {
-    match load(claimed) {
-      ListNode.Nil => (),
-      ListNode.Cons(entry, rest) =>
+    match claimed {
+      List.Nil => (),
+      List.Cons(__cell13) => let (entry, rest) = load(__cell13);
         match entry {
           (idx, info) =>
             check_ctor_entry(real_list, idx, info);
@@ -1060,9 +1060,9 @@ def claim := ⟦
 
   fn check_muts_components(real: List‹MutConst›,
                            claimed: List‹(U64, RevealMutConstInfo)›) {
-    match load(claimed) {
-      ListNode.Nil => (),
-      ListNode.Cons(entry, rest_claimed) =>
+    match claimed {
+      List.Nil => (),
+      List.Cons(__cell14) => let (entry, rest_claimed) = load(__cell14);
         match entry {
           (idx, info) =>
             let real_mc = list_lookup_u64(real, idx);
diff --git a/Ix/IxVM/Kernel/DefEq.lean b/Ix/IxVM/Kernel/DefEq.lean
index 64d9d17e..ba5eec3b 100644
--- a/Ix/IxVM/Kernel/DefEq.lean
+++ b/Ix/IxVM/Kernel/DefEq.lean
@@ -34,16 +34,16 @@ recorded at that tier.
 def defEq := ⟦
   -- Level list equality (semantic, uses level normalization).
   fn level_list_eq(a: List‹KLevel›, b: List‹KLevel›) -> G {
-    match load(a) {
-      ListNode.Nil =>
-        match load(b) {
-          ListNode.Nil => 1,
+    match a {
+      List.Nil =>
+        match b {
+          List.Nil => 1,
           _ => 0,
         },
-      ListNode.Cons(x, xs) =>
-        match load(b) {
-          ListNode.Nil => 0,
-          ListNode.Cons(y, ys) =>
+      List.Cons(__cell1) => let (x, xs) = load(__cell1);
+        match b {
+          List.Nil => 0,
+          List.Cons(__cell2) => let (y, ys) = load(__cell2);
             match level_equal(x, y) {
               0 => 0,
               _ => level_list_eq(xs, ys),
@@ -66,7 +66,7 @@ def defEq := ⟦
       _ =>
         let base = lbr_max(expr_lbr(a), expr_lbr(b));
         match base {
-          0 => k_is_def_eq_core(a, b, store(ListNode.Nil)),
+          0 => k_is_def_eq_core(a, b, List.Nil),
           _ => k_def_eq_rebase(a, b, types, base),
         },
     }
@@ -164,16 +164,16 @@ def defEq := ⟦
   }
 
   fn de_args(aa: List‹KExpr›, bb: List‹KExpr›, types: List‹KExpr›) -> G {
-    match load(aa) {
-      ListNode.Nil =>
-        match load(bb) {
-          ListNode.Nil => 1,
+    match aa {
+      List.Nil =>
+        match bb {
+          List.Nil => 1,
           _ => 0,
         },
-      ListNode.Cons(a, ar) =>
-        match load(bb) {
-          ListNode.Nil => 0,
-          ListNode.Cons(b, br) =>
+      List.Cons(__cell3) => let (a, ar) = load(__cell3);
+        match bb {
+          List.Nil => 0,
+          List.Cons(__cell4) => let (b, br) = load(__cell4);
             match k_is_def_eq(a, b, types) {
               0 => 0,
               _ => de_args(ar, br, types),
@@ -204,8 +204,8 @@ def defEq := ⟦
     match load(e) {
       KExprNode.Lit(lit) =>
         match lit {
-          KLiteral.Nat(n) => (1, mk_nat_lit(store(ListNode.Nil)), n),
-          _ => (0, e, store(ListNode.Nil)),
+          KLiteral.Nat(n) => (1, mk_nat_lit(List.Nil), n),
+          _ => (0, e, List.Nil),
         },
       KExprNode.App(f, a) =>
         match load(f) {
@@ -215,7 +215,7 @@ def defEq := ⟦
                 match nat_offset_of(a) {
                   (_, base, o) => (1, base, klimbs_succ(o)),
                 },
-              _ => (0, e, store(ListNode.Nil)),
+              _ => (0, e, List.Nil),
             },
           KExprNode.App(g, x) =>
             match load(g) {
@@ -230,17 +230,17 @@ def defEq := ⟦
                               (1, base, o) => (1, base, klimbs_add(o, m)),
                               _ => (1, x, m),
                             },
-                          _ => (0, e, store(ListNode.Nil)),
+                          _ => (0, e, List.Nil),
                         },
-                      _ => (0, e, store(ListNode.Nil)),
+                      _ => (0, e, List.Nil),
                     },
-                  _ => (0, e, store(ListNode.Nil)),
+                  _ => (0, e, List.Nil),
                 },
-              _ => (0, e, store(ListNode.Nil)),
+              _ => (0, e, List.Nil),
             },
-          _ => (0, e, store(ListNode.Nil)),
+          _ => (0, e, List.Nil),
         },
-      _ => (0, e, store(ListNode.Nil)),
+      _ => (0, e, List.Nil),
     }
   }
 
@@ -345,7 +345,7 @@ def defEq := ⟦
           KExprNode.Lam(ty_b, body_b) =>
             match k_is_def_eq(ty_a, ty_b, types) {
               1 =>
-                let inner = store(ListNode.Cons(ty_a, types));
+                let inner = List.Cons(store((ty_a, types)));
                 k_is_def_eq(body_a, body_b, inner),
               _ => 0,
             },
@@ -356,7 +356,7 @@ def defEq := ⟦
           KExprNode.Forall(ty_b, body_b) =>
             match k_is_def_eq(ty_a, ty_b, types) {
               1 =>
-                let inner = store(ListNode.Cons(ty_a, types));
+                let inner = List.Cons(store((ty_a, types)));
                 k_is_def_eq(body_a, body_b, inner),
               _ => 0,
             },
@@ -503,10 +503,10 @@ def defEq := ⟦
     let idx_u64 = idx_to_u64(idx);
     let info = ConstantInfo.IPrj(InductiveProj.Mk(idx_u64, block_addr));
     let proj_c = Constant.Mk(info,
-                              store(ListNode.Nil),
-                              store(ListNode.Nil),
-                              store(ListNode.Nil));
-    let bytes = put_constant(proj_c, store(ListNode.Nil));
+                              List.Nil,
+                              List.Nil,
+                              List.Nil);
+    let bytes = put_constant(proj_c, List.Nil);
     bytes_to_addr(bytes)
   }
 
@@ -633,7 +633,7 @@ def defEq := ⟦
             let b_lifted = expr_lift(b, 1, 0);
             let bvar0 = store(KExprNode.BVar(0));
             let b_app = store(KExprNode.App(b_lifted, bvar0));
-            let inner = store(ListNode.Cons(ty_a, types));
+            let inner = List.Cons(store((ty_a, types)));
             k_is_def_eq(body_a, b_app, inner),
         },
       _ => 0,
@@ -723,7 +723,7 @@ def defEq := ⟦
             match k_is_def_eq(ta, tb, types) {
               0 => 0,
               _ =>
-                let types2 = store(ListNode.Cons(ta, types));
+                let types2 = List.Cons(store((ta, types)));
                 k_is_def_eq(ba, bb, types2),
             },
           _ => try_eta_expand(ta, ba, b, types),
@@ -734,7 +734,7 @@ def defEq := ⟦
             match k_is_def_eq(ta, tb, types) {
               0 => 0,
               _ =>
-                let types2 = store(ListNode.Cons(ta, types));
+                let types2 = List.Cons(store((ta, types)));
                 k_is_def_eq(ba, bb, types2),
             },
           _ => 0,
diff --git a/Ix/IxVM/Kernel/Infer.lean b/Ix/IxVM/Kernel/Infer.lean
index f23ad4da..ea1d9a7f 100644
--- a/Ix/IxVM/Kernel/Infer.lean
+++ b/Ix/IxVM/Kernel/Infer.lean
@@ -89,18 +89,18 @@ def infer := ⟦
         match collect_spine(e) {
           (head, args) =>
             let head_ty = k_infer(head, types);
-            k_infer_app_spine_loop(head_ty, args, store(ListNode.Nil), types),
+            k_infer_app_spine_loop(head_ty, args, List.Nil, types),
         },
 
       KExprNode.Lam(ty, body) =>
         k_ensure_sort(ty, types);
-        let types2 = store(ListNode.Cons(ty, types));
+        let types2 = List.Cons(store((ty, types)));
         let body_ty = k_infer(body, types2);
         store(KExprNode.Forall(ty, body_ty)),
 
       KExprNode.Forall(ty, body) =>
         let u1 = k_ensure_sort(ty, types);
-        let types2 = store(ListNode.Cons(ty, types));
+        let types2 = List.Cons(store((ty, types)));
         let u2 = k_ensure_sort(body, types2);
         store(KExprNode.Srt(level_imax(u1, u2))),
 
@@ -130,13 +130,13 @@ def infer := ⟦
   fn k_infer_app_spine_loop(t: KExpr, args: List‹KExpr›,
                                 subs_rev: List‹KExpr›,
                                 types: List‹KExpr›) -> KExpr {
-    match load(args) {
-      ListNode.Nil =>
+    match args {
+      List.Nil =>
         match list_length(subs_rev) {
           0 => t,
           _ => expr_inst_many(t, subs_rev, 0),
         },
-      ListNode.Cons(a, rest) =>
+      List.Cons(__cell1) => let (a, rest) = load(__cell1);
         match load(t) {
           KExprNode.Forall(dom, cod) =>
             let dom_subst = match list_length(subs_rev) {
@@ -145,7 +145,7 @@ def infer := ⟦
             };
             k_check(a, dom_subst, types);
             k_infer_app_spine_loop(cod, rest,
-              store(ListNode.Cons(a, subs_rev)), types),
+              List.Cons(store((a, subs_rev))), types),
           _ =>
             let t_concrete = match list_length(subs_rev) {
               0 => t,
@@ -156,7 +156,7 @@ def infer := ⟦
               KExprNode.Forall(dom, cod) =>
                 k_check(a, dom, types);
                 k_infer_app_spine_loop(cod, rest,
-                  store(ListNode.Cons(a, store(ListNode.Nil))), types),
+                  List.Cons(store((a, List.Nil))), types),
             },
         },
     }
@@ -181,8 +181,8 @@ def infer := ⟦
 
   fn k_infer_lit(lit: KLiteral) -> KExpr {
     match lit {
-      KLiteral.Nat(_) => store(KExprNode.Const(nat_addr(), store(ListNode.Nil))),
-      KLiteral.Str(_) => store(KExprNode.Const(str_addr(), store(ListNode.Nil))),
+      KLiteral.Nat(_) => store(KExprNode.Const(nat_addr(), List.Nil)),
+      KLiteral.Str(_) => store(KExprNode.Const(str_addr(), List.Nil)),
     }
   }
 
@@ -193,8 +193,8 @@ def infer := ⟦
       _ =>
         match load(ty) {
           KExprNode.Forall(_, body) =>
-            match load(args) {
-              ListNode.Cons(arg, rest) =>
+            match args {
+              List.Cons(__cell2) => let (arg, rest) = load(__cell2);
                 let body_substed = expr_inst1(body, arg, 0);
                 peel_params_subst(body_substed, rest, n_params - 1),
             },
@@ -238,7 +238,7 @@ def infer := ⟦
         let ew = whnf(e, types);
         match load(ew) {
           KExprNode.Forall(dom, body) =>
-            let t2 = store(ListNode.Cons(dom, types));
+            let t2 = List.Cons(store((dom, types)));
             peel_n_alls_whnf(body, n - 1, t2),
           _ => ew,
         },
@@ -545,20 +545,20 @@ def infer := ⟦
             let is_ofnat = address_eq(caddr, int_of_nat_addr_dec());
             let is_negsucc = address_eq(caddr, int_neg_succ_addr_dec());
             match is_ofnat + is_negsucc {
-              0 => (0, 0, store(ListNode.Nil)),
+              0 => (0, 0, List.Nil),
               _ =>
                 match load(a) {
                   KExprNode.Lit(lit) =>
                     match lit {
                       KLiteral.Nat(limbs) => (1, is_negsucc, limbs),
-                      _ => (0, 0, store(ListNode.Nil)),
+                      _ => (0, 0, List.Nil),
                     },
-                  _ => (0, 0, store(ListNode.Nil)),
+                  _ => (0, 0, List.Nil),
                 },
             },
-          _ => (0, 0, store(ListNode.Nil)),
+          _ => (0, 0, List.Nil),
         },
-      _ => (0, 0, store(ListNode.Nil)),
+      _ => (0, 0, List.Nil),
     }
   }
 
@@ -568,7 +568,7 @@ def infer := ⟦
       0 => int_of_nat_addr_dec(),
       _ => int_neg_succ_addr_dec(),
     };
-    let head = store(KExprNode.Const(head_addr, store(ListNode.Nil)));
+    let head = store(KExprNode.Const(head_addr, List.Nil));
     let lit = store(KExprNode.Lit(KLiteral.Nat(kl)));
     store(KExprNode.App(head, lit))
   }
@@ -704,14 +704,14 @@ def infer := ⟦
       _ =>
         -- Eq.refl.{1} Bool (Bool.true|Bool.false)
         let one_lvl = store(KLevelNode.Succ(store(KLevelNode.Zero)));
-        let eq_refl_lvls = store(ListNode.Cons(one_lvl, store(ListNode.Nil)));
+        let eq_refl_lvls = List.Cons(store((one_lvl, List.Nil)));
         let eq_refl_c = store(KExprNode.Const(eq_refl_addr_dec(), eq_refl_lvls));
-        let bool_c = store(KExprNode.Const(bool_type_addr_dec(), store(ListNode.Nil)));
+        let bool_c = store(KExprNode.Const(bool_type_addr_dec(), List.Nil));
         let bool_lit_addr = match verdict {
           1 => bool_true_addr(),
           _ => bool_false_addr(),
         };
-        let bool_lit_c = store(KExprNode.Const(bool_lit_addr, store(ListNode.Nil)));
+        let bool_lit_c = store(KExprNode.Const(bool_lit_addr, List.Nil));
         let r1 = store(KExprNode.App(eq_refl_c, bool_c));
         let refl_proof = store(KExprNode.App(r1, bool_lit_c));
         let proof_fn_addr = match is_le {
@@ -726,7 +726,7 @@ def infer := ⟦
               _ => nat_ne_of_beq_eq_false_addr_dec(),
             },
         };
-        let proof_c = store(KExprNode.Const(proof_fn_addr, store(ListNode.Nil)));
+        let proof_c = store(KExprNode.Const(proof_fn_addr, List.Nil));
         let p1 = store(KExprNode.App(proof_c, n_e));
         let p2 = store(KExprNode.App(p1, m_e));
         let proof = store(KExprNode.App(p2, refl_proof));
@@ -773,15 +773,15 @@ def infer := ⟦
   fn str_dec_eq_build(sa: ByteStream, head_addr: Addr, spine: List‹KExpr›,
                        types: List‹KExpr›) -> (G, KExpr) {
     let one_lvl = store(KLevelNode.Succ(store(KLevelNode.Zero)));
-    let eq_refl_lvls = store(ListNode.Cons(one_lvl, store(ListNode.Nil)));
+    let eq_refl_lvls = List.Cons(store((one_lvl, List.Nil)));
     let eq_refl_c = store(KExprNode.Const(eq_refl_addr_dec(), eq_refl_lvls));
     let str_c = store(KExprNode.Const(string_type_addr(),
-                                        store(ListNode.Nil)));
+                                        List.Nil));
     let lit = store(KExprNode.Lit(KLiteral.Str(sa)));
     let r1 = store(KExprNode.App(eq_refl_c, str_c));
     let refl = store(KExprNode.App(r1, lit));
     -- Recover prop from Decidable prop = infer(head, a0, a1).
-    let head_c = store(KExprNode.Const(head_addr, store(ListNode.Nil)));
+    let head_c = store(KExprNode.Const(head_addr, List.Nil));
     let two_args = list_take(spine, 2);
     let call_expr = apply_spine(head_c, two_args);
     let call_ty = k_infer(call_expr, types);
@@ -793,7 +793,7 @@ def infer := ⟦
           _ =>
             let prop = list_lookup(dec_args, 0);
             let dec_c = store(KExprNode.Const(decidable_is_true_addr_dec(),
-                                                store(ListNode.Nil)));
+                                                List.Nil));
             let d1 = store(KExprNode.App(dec_c, prop));
             let d2 = store(KExprNode.App(d1, refl));
             let post = list_drop(spine, 2);
@@ -822,7 +822,7 @@ def infer := ⟦
           1 => (0, store(KExprNode.BVar(0))),
           _ =>
             let prop = list_lookup(dec_args, 0);
-            let dec_c = store(KExprNode.Const(dec_addr, store(ListNode.Nil)));
+            let dec_c = store(KExprNode.Const(dec_addr, List.Nil));
             let d1 = store(KExprNode.App(dec_c, prop));
             let d2 = store(KExprNode.App(d1, proof));
             let post = list_drop(spine, 2);
diff --git a/Ix/IxVM/Kernel/InferOnly.lean b/Ix/IxVM/Kernel/InferOnly.lean
index 8ed67c6b..f4f0cebc 100644
--- a/Ix/IxVM/Kernel/InferOnly.lean
+++ b/Ix/IxVM/Kernel/InferOnly.lean
@@ -141,13 +141,13 @@ def inferOnly := ⟦
         },
 
       KExprNode.Lam(ty, body) =>
-        let types2 = store(ListNode.Cons(ty, types));
+        let types2 = List.Cons(store((ty, types)));
         let body_ty = k_infer_only(body, types2);
         store(KExprNode.Forall(ty, body_ty)),
 
       KExprNode.Forall(ty, body) =>
         let u1 = ensure_sort_only(ty, types);
-        let types2 = store(ListNode.Cons(ty, types));
+        let types2 = List.Cons(store((ty, types)));
         let u2 = ensure_sort_only(body, types2);
         store(KExprNode.Srt(level_imax(u1, u2))),
 
@@ -158,9 +158,9 @@ def inferOnly := ⟦
       KExprNode.Lit(lit) =>
         match lit {
           KLiteral.Nat(_) =>
-            store(KExprNode.Const(nat_addr_io(), store(ListNode.Nil))),
+            store(KExprNode.Const(nat_addr_io(), List.Nil)),
           KLiteral.Str(_) =>
-            store(KExprNode.Const(str_addr_io(), store(ListNode.Nil))),
+            store(KExprNode.Const(str_addr_io(), List.Nil)),
         },
 
       -- Proj arm: minimal, mirrors k_infer_proj without prop checks.
@@ -213,8 +213,8 @@ def inferOnly := ⟦
       _ =>
         match load(ty) {
           KExprNode.Forall(_, body) =>
-            match load(args) {
-              ListNode.Cons(arg, rest) =>
+            match args {
+              List.Cons(__cell1) => let (arg, rest) = load(__cell1);
                 let body_substed = expr_inst1(body, arg, 0);
                 io_peel_params_subst(body_substed, rest, n_params - 1),
             },
diff --git a/Ix/IxVM/Kernel/Klimbs.lean b/Ix/IxVM/Kernel/Klimbs.lean
index 89dd9b89..51025693 100644
--- a/Ix/IxVM/Kernel/Klimbs.lean
+++ b/Ix/IxVM/Kernel/Klimbs.lean
@@ -39,16 +39,16 @@ def klimbs := ⟦
 
   -- Mirror: BigUint::succ. Increment a KLimbs by 1; ripple carry.
   fn klimbs_succ(n: KLimbs) -> KLimbs {
-    match load(n) {
-      ListNode.Nil =>
-        store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))),
-      ListNode.Cons(limb, rest) =>
+    match n {
+      List.Nil =>
+        List.Cons(store(([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], List.Nil))),
+      List.Cons(__cell1) => let (limb, rest) = load(__cell1);
         let pair = u64_add(limb, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
         match pair {
           (sum, carry) =>
             match carry {
-              0 => store(ListNode.Cons(sum, rest)),
-              _ => store(ListNode.Cons(sum, klimbs_succ(rest))),
+              0 => List.Cons(store((sum, rest))),
+              _ => List.Cons(store((sum, klimbs_succ(rest)))),
             },
         },
     }
@@ -59,20 +59,20 @@ def klimbs := ⟦
   -- Asymmetric lengths handled by terminating on shorter list and
   -- propagating carry into the longer.
   fn klimbs_add_carry(a: KLimbs, b: KLimbs, carry: G) -> KLimbs {
-    match load(a) {
-      ListNode.Nil =>
+    match a {
+      List.Nil =>
         match carry {
           0 => b,
           _ => klimbs_succ(b),
         },
-      ListNode.Cons(la, ra) =>
-        match load(b) {
-          ListNode.Nil =>
+      List.Cons(__cell2) => let (la, ra) = load(__cell2);
+        match b {
+          List.Nil =>
             match carry {
               0 => a,
               _ => klimbs_succ(a),
             },
-          ListNode.Cons(lb, rb) =>
+          List.Cons(__cell3) => let (lb, rb) = load(__cell3);
             let pair1 = u64_add(la, lb);
             match pair1 {
               (sum1, carry1) =>
@@ -82,7 +82,7 @@ def klimbs := ⟦
                     -- carry1, carry2 mutually exclusive: carry1=1 ⇒ sum1 ≤
                     -- 2^64-2 ⇒ sum1 + carry_in ≤ 2^64-1 ⇒ carry2=0.
                     let total_carry = to_field(carry1) + to_field(carry2);
-                    store(ListNode.Cons(sum2, klimbs_add_carry(ra, rb, total_carry))),
+                    List.Cons(store((sum2, klimbs_add_carry(ra, rb, total_carry)))),
                 },
             },
         },
@@ -134,13 +134,13 @@ def klimbs := ⟦
   -- final borrow is 1 OR `b` has more limbs than `a`, return 0 (Nil).
   -- Otherwise normalize trailing zero limbs.
   fn klimbs_sub_borrow(a: KLimbs, b: KLimbs, borrow: G) -> (KLimbs, G) {
-    match load(a) {
-      ListNode.Nil =>
-        match load(b) {
-          ListNode.Nil =>
+    match a {
+      List.Nil =>
+        match b {
+          List.Nil =>
             -- 0 - 0 - borrow: borrow=1 → underflow.
-            (store(ListNode.Nil), borrow),
-          ListNode.Cons(_, _) =>
+            (List.Nil, borrow),
+          List.Cons(_) =>
             -- 0 - non-empty. A non-empty limb list is not necessarily a
             -- non-zero number: trailing zero limbs are a valid encoding, and
             -- `klimbs_div`/`klimbs_mod` hand back the raw prover-supplied
@@ -148,13 +148,13 @@ def klimbs := ⟦
             -- non-empty `b` as an underflow made `klimbs_le([3], [2,0])`
             -- certify "3 <= 2".
             match klimbs_is_zero(b) {
-              1 => (store(ListNode.Nil), borrow),
-              _ => (store(ListNode.Nil), 1),
+              1 => (List.Nil, borrow),
+              _ => (List.Nil, 1),
             },
         },
-      ListNode.Cons(la, ra) =>
-        match load(b) {
-          ListNode.Nil =>
+      List.Cons(__cell4) => let (la, ra) = load(__cell4);
+        match b {
+          List.Nil =>
             -- a - 0 - borrow: subtract borrow from la, propagate.
             match borrow {
               0 => (a, 0),
@@ -162,14 +162,14 @@ def klimbs := ⟦
                 let pair = u64_sub_with_borrow(la, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
                 match pair {
                   (diff, br) =>
-                    let pair2 = klimbs_sub_borrow(ra, store(ListNode.Nil), br);
+                    let pair2 = klimbs_sub_borrow(ra, List.Nil, br);
                     match pair2 {
                       (rest_res, br2) =>
-                        (store(ListNode.Cons(diff, rest_res)), br2),
+                        (List.Cons(store((diff, rest_res))), br2),
                     },
                 },
             },
-          ListNode.Cons(lb, rb) =>
+          List.Cons(__cell5) => let (lb, rb) = load(__cell5);
             let pair1 = u64_sub_with_borrow(la, lb);
             match pair1 {
               (sum1, br1) =>
@@ -182,7 +182,7 @@ def klimbs := ⟦
                     let rec_pair = klimbs_sub_borrow(ra, rb, total);
                     match rec_pair {
                       (rest_res, br_final) =>
-                        (store(ListNode.Cons(sum2, rest_res)), br_final),
+                        (List.Cons(store((sum2, rest_res))), br_final),
                     },
                 },
             },
@@ -204,31 +204,31 @@ def klimbs := ⟦
   -- Lean answers `true`. `u8_range_check` takes a pair per lookup row,
   -- so eight bytes cost four.
   fn glimbs_to_klimbs(n: List‹[G; 8]›) -> KLimbs {
-    match load(n) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(limb, rest) =>
+    match n {
+      List.Nil => List.Nil,
+      List.Cons(__cell6) => let (limb, rest) = load(__cell6);
         let [b0, b1, b2, b3, b4, b5, b6, b7] = limb;
         let (c0, c1) = u8_range_check(b0, b1);
         let (c2, c3) = u8_range_check(b2, b3);
         let (c4, c5) = u8_range_check(b4, b5);
         let (c6, c7) = u8_range_check(b6, b7);
-        store(ListNode.Cons([c0, c1, c2, c3, c4, c5, c6, c7],
-          glimbs_to_klimbs(rest))),
+        List.Cons(store(([c0, c1, c2, c3, c4, c5, c6, c7],
+          glimbs_to_klimbs(rest)))),
     }
   }
 
   fn klimbs_normalize(n: KLimbs) -> KLimbs {
-    match load(n) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(limb, rest) =>
+    match n {
+      List.Nil => List.Nil,
+      List.Cons(__cell7) => let (limb, rest) = load(__cell7);
         let normalized_rest = klimbs_normalize(rest);
-        match load(normalized_rest) {
-          ListNode.Nil =>
+        match normalized_rest {
+          List.Nil =>
             match u64_is_zero(limb) {
-              1 => store(ListNode.Nil),
-              0 => store(ListNode.Cons(limb, store(ListNode.Nil))),
+              1 => List.Nil,
+              0 => List.Cons(store((limb, List.Nil))),
             },
-          _ => store(ListNode.Cons(limb, normalized_rest)),
+          _ => List.Cons(store((limb, normalized_rest))),
         },
     }
   }
@@ -238,7 +238,7 @@ def klimbs := ⟦
     match pair {
       (result, borrow) =>
         match borrow {
-          1 => store(ListNode.Nil),
+          1 => List.Nil,
           0 => klimbs_normalize(result),
         },
     }
@@ -248,15 +248,15 @@ def klimbs := ⟦
   -- Uses saturating sub: a ≤ b iff (a - b) saturates to 0.
   fn klimbs_le(a: KLimbs, b: KLimbs) -> G {
     let diff = klimbs_sub(a, b);
-    match load(diff) {
-      ListNode.Nil => 1,
+    match diff {
+      List.Nil => 1,
       _ => 0,
     }
   }
 
   -- Mirror: Nat.pred. Saturating decrement; pred(0) = 0.
   fn klimbs_dec(a: KLimbs) -> KLimbs {
-    let one = store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
+    let one = List.Cons(store(([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], List.Nil)));
     klimbs_sub(a, one)
   }
 
@@ -452,14 +452,14 @@ def klimbs := ⟦
 
   -- Mirror: BigUint::mul. Limb-wise schoolbook multiply.
   fn klimbs_mul(a: KLimbs, b: KLimbs) -> KLimbs {
-    klimbs_mul_outer(a, b, store(ListNode.Nil), 0)
+    klimbs_mul_outer(a, b, List.Nil, 0)
   }
 
   fn klimbs_mul_outer(a: KLimbs, b: KLimbs, acc: KLimbs, shift: G) -> KLimbs {
-    match load(a) {
-      ListNode.Nil => acc,
-      ListNode.Cons(a_limb, rest) =>
-        let prod = klimbs_mul_single(a_limb, b, [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil));
+    match a {
+      List.Nil => acc,
+      List.Cons(__cell8) => let (a_limb, rest) = load(__cell8);
+        let prod = klimbs_mul_single(a_limb, b, [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], List.Nil);
         let shifted = klimbs_shl_limbs(prod, shift);
         let new_acc = klimbs_add(acc, shifted);
         klimbs_mul_outer(rest, b, new_acc, shift + 1),
@@ -467,13 +467,13 @@ def klimbs := ⟦
   }
 
   fn klimbs_mul_single(a_limb: U64, b: KLimbs, carry: U64, acc: KLimbs) -> KLimbs {
-    match load(b) {
-      ListNode.Nil =>
+    match b {
+      List.Nil =>
         match u64_is_zero(carry) {
           1 => acc,
           0 => list_snoc(acc, carry),
         },
-      ListNode.Cons(b_limb, rest) =>
+      List.Cons(__cell9) => let (b_limb, rest) = load(__cell9);
         match u64_mul(a_limb, b_limb) {
           (lo, hi) =>
             match u64_add(lo, carry) {
@@ -492,14 +492,14 @@ def klimbs := ⟦
     match shift {
       0 => x,
       _ =>
-        let prepended = store(ListNode.Cons([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], x));
+        let prepended = List.Cons(store(([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], x)));
         klimbs_shl_limbs(prepended, shift - 1),
     }
   }
 
   fn klimbs_is_zero(x: KLimbs) -> G {
-    match load(klimbs_normalize(x)) {
-      ListNode.Nil => 1,
+    match klimbs_normalize(x) {
+      List.Nil => 1,
       _ => 0,
     }
   }
@@ -583,9 +583,9 @@ def klimbs := ⟦
   -- division per step is O(1) work.
   fn klimbs_pow(base: KLimbs, exp: KLimbs) -> KLimbs {
     match klimbs_is_zero(exp) {
-      1 => store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))),
+      1 => List.Cons(store(([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], List.Nil))),
       0 =>
-        let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
+        let two = List.Cons(store(([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], List.Nil)));
         let (half, r) = klimbs_div_mod(exp, two);
         let sq = klimbs_pow(klimbs_normalize(klimbs_mul(base, base)), klimbs_normalize(half));
         match klimbs_is_zero(r) {
@@ -619,52 +619,52 @@ def klimbs := ⟦
 
   -- Mirror: BigUint::bitand. Walks parallel limbs; result length = min(len(a), len(b)).
   fn klimbs_land(a: KLimbs, b: KLimbs) -> KLimbs {
-    match load(a) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(la, ra) =>
-        match load(b) {
-          ListNode.Nil => store(ListNode.Nil),
-          ListNode.Cons(lb, rb) =>
-            store(ListNode.Cons(u64_and(la, lb), klimbs_land(ra, rb))),
+    match a {
+      List.Nil => List.Nil,
+      List.Cons(__cell10) => let (la, ra) = load(__cell10);
+        match b {
+          List.Nil => List.Nil,
+          List.Cons(__cell11) => let (lb, rb) = load(__cell11);
+            List.Cons(store((u64_and(la, lb), klimbs_land(ra, rb)))),
         },
     }
   }
 
   -- Mirror: BigUint::bitor. Result length = max(len(a), len(b)); shorter is zero-padded.
   fn klimbs_lor(a: KLimbs, b: KLimbs) -> KLimbs {
-    match load(a) {
-      ListNode.Nil => b,
-      ListNode.Cons(la, ra) =>
-        match load(b) {
-          ListNode.Nil => a,
-          ListNode.Cons(lb, rb) =>
-            store(ListNode.Cons(u64_or(la, lb), klimbs_lor(ra, rb))),
+    match a {
+      List.Nil => b,
+      List.Cons(__cell12) => let (la, ra) = load(__cell12);
+        match b {
+          List.Nil => a,
+          List.Cons(__cell13) => let (lb, rb) = load(__cell13);
+            List.Cons(store((u64_or(la, lb), klimbs_lor(ra, rb)))),
         },
     }
   }
 
   -- Mirror: BigUint::bitxor. Result length = max(len(a), len(b)); zero-padded shorter.
   fn klimbs_xor_op(a: KLimbs, b: KLimbs) -> KLimbs {
-    match load(a) {
-      ListNode.Nil => b,
-      ListNode.Cons(la, ra) =>
-        match load(b) {
-          ListNode.Nil => a,
-          ListNode.Cons(lb, rb) =>
-            store(ListNode.Cons(u64_xor_kbits(la, lb), klimbs_xor_op(ra, rb))),
+    match a {
+      List.Nil => b,
+      List.Cons(__cell14) => let (la, ra) = load(__cell14);
+        match b {
+          List.Nil => a,
+          List.Cons(__cell15) => let (lb, rb) = load(__cell15);
+            List.Cons(store((u64_xor_kbits(la, lb), klimbs_xor_op(ra, rb)))),
         },
     }
   }
 
   -- Shift left by n bits via repeated multiplication by 2.
   fn klimbs_shl(a: KLimbs, n: KLimbs) -> KLimbs {
-    let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
+    let two = List.Cons(store(([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], List.Nil)));
     klimbs_mul(a, klimbs_pow(two, n))
   }
 
   -- Shift right by n bits via integer division by 2^n.
   fn klimbs_shr(a: KLimbs, n: KLimbs) -> KLimbs {
-    let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
+    let two = List.Cons(store(([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], List.Nil)));
     klimbs_div(a, klimbs_pow(two, n))
   }
 ⟧
diff --git a/Ix/IxVM/Kernel/Levels.lean b/Ix/IxVM/Kernel/Levels.lean
index a01a780f..0bb8b26e 100644
--- a/Ix/IxVM/Kernel/Levels.lean
+++ b/Ix/IxVM/Kernel/Levels.lean
@@ -88,16 +88,16 @@ def levels := ⟦
 
   -- Lexicographic compare of sorted G-lists: 0 = eq, 1 = a < b, 2 = a > b.
   fn glist_cmp(a: List‹G›, b: List‹G›) -> G {
-    match load(a) {
-      ListNode.Nil =>
-        match load(b) {
-          ListNode.Nil => 0,
-          ListNode.Cons(_, _) => 1,
+    match a {
+      List.Nil =>
+        match b {
+          List.Nil => 0,
+          List.Cons(_) => 1,
         },
-      ListNode.Cons(x, ar) =>
-        match load(b) {
-          ListNode.Nil => 2,
-          ListNode.Cons(y, br) =>
+      List.Cons(__cell1) => let (x, ar) = load(__cell1);
+        match b {
+          List.Nil => 2,
+          List.Cons(__cell2) => let (y, br) = load(__cell2);
             match u32_less_than(x, y) {
               1 => 1,
               0 =>
@@ -112,12 +112,12 @@ def levels := ⟦
 
   -- Sorted-list subset test.
   fn glist_subset(xs: List‹G›, ys: List‹G›) -> G {
-    match load(xs) {
-      ListNode.Nil => 1,
-      ListNode.Cons(x, xr) =>
-        match load(ys) {
-          ListNode.Nil => 0,
-          ListNode.Cons(y, yr) =>
+    match xs {
+      List.Nil => 1,
+      List.Cons(__cell3) => let (x, xr) = load(__cell3);
+        match ys {
+          List.Nil => 0,
+          List.Cons(__cell4) => let (y, yr) = load(__cell4);
             match u32_less_than(x, y) {
               1 => 0,
               0 =>
@@ -131,16 +131,16 @@ def levels := ⟦
   }
 
   fn glist_eq_len(a: List‹G›, b: List‹G›) -> G {
-    match load(a) {
-      ListNode.Nil =>
-        match load(b) {
-          ListNode.Nil => 1,
-          ListNode.Cons(_, _) => 0,
+    match a {
+      List.Nil =>
+        match b {
+          List.Nil => 1,
+          List.Cons(_) => 0,
         },
-      ListNode.Cons(_, ar) =>
-        match load(b) {
-          ListNode.Nil => 0,
-          ListNode.Cons(_, br) => glist_eq_len(ar, br),
+      List.Cons(__cell5) => let (_, ar) = load(__cell5);
+        match b {
+          List.Nil => 0,
+          List.Cons(__cell6) => let (_, br) = load(__cell6); glist_eq_len(ar, br),
         },
     }
   }
@@ -148,17 +148,17 @@ def levels := ⟦
   -- Insert into a sorted G-list. Returns (1, new_list) on insert,
   -- (0, original) when already present. Mirrors level.rs ordered_insert.
   fn glist_ordered_insert(x: G, l: List‹G›) -> (G, List‹G›) {
-    match load(l) {
-      ListNode.Nil => (1, store(ListNode.Cons(x, store(ListNode.Nil)))),
-      ListNode.Cons(h, r) =>
+    match l {
+      List.Nil => (1, List.Cons(store((x, List.Nil)))),
+      List.Cons(__cell7) => let (h, r) = load(__cell7);
         match u32_less_than(x, h) {
-          1 => (1, store(ListNode.Cons(x, l))),
+          1 => (1, List.Cons(store((x, l)))),
           0 =>
             match u32_less_than(h, x) {
               0 => (0, l),
               1 =>
                 match glist_ordered_insert(x, r) {
-                  (f, r2) => (f, store(ListNode.Cons(h, r2))),
+                  (f, r2) => (f, List.Cons(store((h, r2)))),
                 },
             },
         },
@@ -168,20 +168,20 @@ def levels := ⟦
   -- Insert (idx, k) into an idx-sorted var list; on duplicate idx keep
   -- the max offset. Mirrors Node::add_var.
   fn nlvars_add(vars: List‹&NLVar›, idx: G, k: G) -> List‹&NLVar› {
-    match load(vars) {
-      ListNode.Nil =>
-        store(ListNode.Cons(store(NLVar.Mk(idx, k)), store(ListNode.Nil))),
-      ListNode.Cons(v, rest) =>
+    match vars {
+      List.Nil =>
+        List.Cons(store((store(NLVar.Mk(idx, k)), List.Nil))),
+      List.Cons(__cell8) => let (v, rest) = load(__cell8);
         match load(v) {
           NLVar.Mk(vi, vo) =>
             match u32_less_than(idx, vi) {
-              1 => store(ListNode.Cons(store(NLVar.Mk(idx, k)), vars)),
+              1 => List.Cons(store((store(NLVar.Mk(idx, k)), vars))),
               0 =>
                 match u32_less_than(vi, idx) {
-                  1 => store(ListNode.Cons(v, nlvars_add(rest, idx, k))),
+                  1 => List.Cons(store((v, nlvars_add(rest, idx, k)))),
                   0 =>
                     match u32_less_than(vo, k) {
-                      1 => store(ListNode.Cons(store(NLVar.Mk(vi, k)), rest)),
+                      1 => List.Cons(store((store(NLVar.Mk(vi, k)), rest))),
                       0 => vars,
                     },
                 },
@@ -191,16 +191,16 @@ def levels := ⟦
   }
 
   fn nlvars_eq(a: List‹&NLVar›, b: List‹&NLVar›) -> G {
-    match load(a) {
-      ListNode.Nil =>
-        match load(b) {
-          ListNode.Nil => 1,
-          ListNode.Cons(_, _) => 0,
+    match a {
+      List.Nil =>
+        match b {
+          List.Nil => 1,
+          List.Cons(_) => 0,
         },
-      ListNode.Cons(x, ar) =>
-        match load(b) {
-          ListNode.Nil => 0,
-          ListNode.Cons(y, br) =>
+      List.Cons(__cell9) => let (x, ar) = load(__cell9);
+        match b {
+          List.Nil => 0,
+          List.Cons(__cell10) => let (y, br) = load(__cell10);
             match load(x) {
               NLVar.Mk(xi, xo) =>
                 match load(y) {
@@ -220,9 +220,9 @@ def levels := ⟦
   }
 
   fn nlvars_max_offset(vars: List‹&NLVar›) -> G {
-    match load(vars) {
-      ListNode.Nil => 0,
-      ListNode.Cons(v, rest) =>
+    match vars {
+      List.Nil => 0,
+      List.Cons(__cell11) => let (v, rest) = load(__cell11);
         match load(v) {
           NLVar.Mk(_, vo) =>
             let m = nlvars_max_offset(rest);
@@ -237,24 +237,24 @@ def levels := ⟦
   -- Keep x in xs unless ys has the same idx with offset >= x's.
   -- Mirrors level.rs subsume_vars (sorted merge walk).
   fn nlvars_subsume(xs: List‹&NLVar›, ys: List‹&NLVar›) -> List‹&NLVar› {
-    match load(xs) {
-      ListNode.Nil => xs,
-      ListNode.Cons(x, xr) =>
-        match load(ys) {
-          ListNode.Nil => xs,
-          ListNode.Cons(y, yr) =>
+    match xs {
+      List.Nil => xs,
+      List.Cons(__cell12) => let (x, xr) = load(__cell12);
+        match ys {
+          List.Nil => xs,
+          List.Cons(__cell13) => let (y, yr) = load(__cell13);
             match load(x) {
               NLVar.Mk(xi, xo) =>
                 match load(y) {
                   NLVar.Mk(yi, yo) =>
                     match u32_less_than(xi, yi) {
-                      1 => store(ListNode.Cons(x, nlvars_subsume(xr, ys))),
+                      1 => List.Cons(store((x, nlvars_subsume(xr, ys)))),
                       0 =>
                         match u32_less_than(yi, xi) {
                           1 => nlvars_subsume(xs, yr),
                           0 =>
                             match u32_less_than(yo, xo) {
-                              1 => store(ListNode.Cons(x, nlvars_subsume(xr, yr))),
+                              1 => List.Cons(store((x, nlvars_subsume(xr, yr)))),
                               0 => nlvars_subsume(xr, yr),
                             },
                         },
@@ -273,33 +273,33 @@ def levels := ⟦
     match k {
       0 => acc,
       1 =>
-        match load(path) {
-          ListNode.Nil => nl_add_const_go(acc, path, k),
-          ListNode.Cons(_, _) => acc,
+        match path {
+          List.Nil => nl_add_const_go(acc, path, k),
+          List.Cons(_) => acc,
         },
       _ => nl_add_const_go(acc, path, k),
     }
   }
 
   fn nl_add_const_go(acc: List‹&NLEntry›, path: List‹G›, k: G) -> List‹&NLEntry› {
-    match load(acc) {
-      ListNode.Nil =>
-        store(ListNode.Cons(
-          store(NLEntry.Mk(path, k, store(ListNode.Nil))),
-          store(ListNode.Nil))),
-      ListNode.Cons(e, rest) =>
+    match acc {
+      List.Nil =>
+        List.Cons(store((
+          store(NLEntry.Mk(path, k, List.Nil)),
+          List.Nil))),
+      List.Cons(__cell14) => let (e, rest) = load(__cell14);
         match load(e) {
           NLEntry.Mk(ep, ec, ev) =>
             match glist_cmp(path, ep) {
               0 =>
                 match u32_less_than(ec, k) {
-                  1 => store(ListNode.Cons(store(NLEntry.Mk(ep, k, ev)), rest)),
+                  1 => List.Cons(store((store(NLEntry.Mk(ep, k, ev)), rest))),
                   0 => acc,
                 },
               1 =>
-                store(ListNode.Cons(
-                  store(NLEntry.Mk(path, k, store(ListNode.Nil))), acc)),
-              _ => store(ListNode.Cons(e, nl_add_const_go(rest, path, k))),
+                List.Cons(store((
+                  store(NLEntry.Mk(path, k, List.Nil)), acc))),
+              _ => List.Cons(store((e, nl_add_const_go(rest, path, k)))),
             },
         },
     }
@@ -307,25 +307,25 @@ def levels := ⟦
 
   -- Add var (idx, k) to the entry at `path` (path-sorted insert).
   fn nl_add_var(acc: List‹&NLEntry›, path: List‹G›, idx: G, k: G) -> List‹&NLEntry› {
-    match load(acc) {
-      ListNode.Nil =>
-        store(ListNode.Cons(
+    match acc {
+      List.Nil =>
+        List.Cons(store((
           store(NLEntry.Mk(path, 0,
-            store(ListNode.Cons(store(NLVar.Mk(idx, k)), store(ListNode.Nil))))),
-          store(ListNode.Nil))),
-      ListNode.Cons(e, rest) =>
+            List.Cons(store((store(NLVar.Mk(idx, k)), List.Nil))))),
+          List.Nil))),
+      List.Cons(__cell15) => let (e, rest) = load(__cell15);
         match load(e) {
           NLEntry.Mk(ep, ec, ev) =>
             match glist_cmp(path, ep) {
               0 =>
-                store(ListNode.Cons(
-                  store(NLEntry.Mk(ep, ec, nlvars_add(ev, idx, k))), rest)),
+                List.Cons(store((
+                  store(NLEntry.Mk(ep, ec, nlvars_add(ev, idx, k))), rest))),
               1 =>
-                store(ListNode.Cons(
+                List.Cons(store((
                   store(NLEntry.Mk(path, 0,
-                    store(ListNode.Cons(store(NLVar.Mk(idx, k)), store(ListNode.Nil))))),
-                  acc)),
-              _ => store(ListNode.Cons(e, nl_add_var(rest, path, idx, k))),
+                    List.Cons(store((store(NLVar.Mk(idx, k)), List.Nil))))),
+                  acc))),
+              _ => List.Cons(store((e, nl_add_var(rest, path, idx, k)))),
             },
         },
     }
@@ -395,19 +395,19 @@ def levels := ⟦
   -- they pass as `rem`.
   fn nl_subsumption_walk(rem: List‹&NLEntry›,
                          snapshot: List‹&NLEntry›) -> List‹&NLEntry› {
-    match load(rem) {
-      ListNode.Nil => rem,
-      ListNode.Cons(e, rest) =>
-        store(ListNode.Cons(
+    match rem {
+      List.Nil => rem,
+      List.Cons(__cell16) => let (e, rest) = load(__cell16);
+        List.Cons(store((
           nl_subsume_entry(e, snapshot),
-          nl_subsumption_walk(rest, snapshot))),
+          nl_subsumption_walk(rest, snapshot)))),
     }
   }
 
   fn nl_subsume_entry(e: &NLEntry, snap: List‹&NLEntry›) -> &NLEntry {
-    match load(snap) {
-      ListNode.Nil => e,
-      ListNode.Cons(s, srest) =>
+    match snap {
+      List.Nil => e,
+      List.Cons(__cell17) => let (s, srest) = load(__cell17);
         match load(e) {
           NLEntry.Mk(p1, c1, v1) =>
             match load(s) {
@@ -424,9 +424,9 @@ def levels := ⟦
                           1 => 1,
                           0 => u32_less_than(c2, c1),
                         };
-                        let or2 = match load(v2) {
-                          ListNode.Nil => 1,
-                          ListNode.Cons(_, _) =>
+                        let or2 = match v2 {
+                          List.Nil => 1,
+                          List.Cons(_) =>
                             u32_less_than(nlvars_max_offset(v1) + 1, c1),
                         };
                         match or1 * or2 {
@@ -437,9 +437,9 @@ def levels := ⟦
                     let v1n = match same {
                       1 => v1,
                       0 =>
-                        match load(v2) {
-                          ListNode.Nil => v1,
-                          ListNode.Cons(_, _) => nlvars_subsume(v1, v2),
+                        match v2 {
+                          List.Nil => v1,
+                          List.Cons(_) => nlvars_subsume(v1, v2),
                         },
                     };
                     nl_subsume_entry(store(NLEntry.Mk(p1, c1n, v1n)), srest),
@@ -455,16 +455,16 @@ def levels := ⟦
   -- equality strictly finer than semantic equality (3 of 3,253,373
   -- whole-Mathlib entries). Mirrors level.rs norm_level_eq's filter.
   fn nl_skip_empty(l: List‹&NLEntry›) -> List‹&NLEntry› {
-    match load(l) {
-      ListNode.Nil => l,
-      ListNode.Cons(e, rest) =>
+    match l {
+      List.Nil => l,
+      List.Cons(__cell18) => let (e, rest) = load(__cell18);
         match load(e) {
           NLEntry.Mk(_, c, v) =>
             match c {
               0 =>
-                match load(v) {
-                  ListNode.Nil => nl_skip_empty(rest),
-                  ListNode.Cons(_, _) => l,
+                match v {
+                  List.Nil => nl_skip_empty(rest),
+                  List.Cons(_) => l,
                 },
               _ => l,
             },
@@ -479,16 +479,16 @@ def levels := ⟦
   fn nl_eq(a0: List‹&NLEntry›, b0: List‹&NLEntry›) -> G {
     let a = nl_skip_empty(a0);
     let b = nl_skip_empty(b0);
-    match load(a) {
-      ListNode.Nil =>
-        match load(b) {
-          ListNode.Nil => 1,
-          ListNode.Cons(_, _) => 0,
+    match a {
+      List.Nil =>
+        match b {
+          List.Nil => 1,
+          List.Cons(_) => 0,
         },
-      ListNode.Cons(x, ar) =>
-        match load(b) {
-          ListNode.Nil => 0,
-          ListNode.Cons(y, br) =>
+      List.Cons(__cell19) => let (x, ar) = load(__cell19);
+        match b {
+          List.Nil => 0,
+          List.Cons(__cell20) => let (y, br) = load(__cell20);
             match load(x) {
               NLEntry.Mk(xp, xc, xv) =>
                 match load(y) {
@@ -517,9 +517,9 @@ def levels := ⟦
   -- >= off + 1 because idx IN p2 implies the param is >= 1 there.
   -- Mirrors level.rs covers_const (the fixed, split-search version).
   fn nl_covers_const(l2: List‹&NLEntry›, p1: List‹G›, c: G) -> G {
-    match load(l2) {
-      ListNode.Nil => 0,
-      ListNode.Cons(e, rest) =>
+    match l2 {
+      List.Nil => 0,
+      List.Cons(__cell21) => let (e, rest) = load(__cell21);
         match load(e) {
           NLEntry.Mk(p2, c2, v2) =>
             match glist_subset(p2, p1) {
@@ -540,9 +540,9 @@ def levels := ⟦
 
   -- Any var with offset + 1 >= c?
   fn nlvars_any_offset_geq(vars: List‹&NLVar›, c: G) -> G {
-    match load(vars) {
-      ListNode.Nil => 0,
-      ListNode.Cons(v, rest) =>
+    match vars {
+      List.Nil => 0,
+      List.Cons(__cell22) => let (v, rest) = load(__cell22);
         match load(v) {
           NLVar.Mk(_, vo) =>
             match u32_less_than(vo + 1, c) {
@@ -556,9 +556,9 @@ def levels := ⟦
   -- Does some entry (p2, n2) in l2 with p2 SUBSET-OF p1 contain a var
   -- (w, off2) with off2 >= off? Mirrors level.rs covers_var.
   fn nl_covers_var(l2: List‹&NLEntry›, p1: List‹G›, w: G, off: G) -> G {
-    match load(l2) {
-      ListNode.Nil => 0,
-      ListNode.Cons(e, rest) =>
+    match l2 {
+      List.Nil => 0,
+      List.Cons(__cell23) => let (e, rest) = load(__cell23);
         match load(e) {
           NLEntry.Mk(p2, _, v2) =>
             match glist_subset(p2, p1) {
@@ -574,9 +574,9 @@ def levels := ⟦
   }
 
   fn nlvars_dominates(vars: List‹&NLVar›, w: G, off: G) -> G {
-    match load(vars) {
-      ListNode.Nil => 0,
-      ListNode.Cons(v, rest) =>
+    match vars {
+      List.Nil => 0,
+      List.Cons(__cell24) => let (v, rest) = load(__cell24);
         match load(v) {
           NLVar.Mk(vi, vo) =>
             match vi - w {
@@ -596,9 +596,9 @@ def levels := ⟦
   -- Mirrors level.rs norm_level_le (with its covers split, sound where
   -- Lean4Lean's single-entry search is incomplete).
   fn nl_le(l1: List‹&NLEntry›, l2: List‹&NLEntry›) -> G {
-    match load(l1) {
-      ListNode.Nil => 1,
-      ListNode.Cons(e, rest) =>
+    match l1 {
+      List.Nil => 1,
+      List.Cons(__cell25) => let (e, rest) = load(__cell25);
         match load(e) {
           NLEntry.Mk(p1, c1, v1) =>
             let c_ok = match c1 {
@@ -618,9 +618,9 @@ def levels := ⟦
   }
 
   fn nl_le_vars(vars: List‹&NLVar›, l2: List‹&NLEntry›, p1: List‹G›) -> G {
-    match load(vars) {
-      ListNode.Nil => 1,
-      ListNode.Cons(v, rest) =>
+    match vars {
+      List.Nil => 1,
+      List.Cons(__cell26) => let (v, rest) = load(__cell26);
         match load(v) {
           NLVar.Mk(vi, vo) =>
             match nl_covers_var(l2, p1, vi, vo) {
@@ -634,10 +634,10 @@ def levels := ⟦
   -- Keyed on the level alone: each distinct level normalizes once per run.
   -- Seeded with the empty-path entry, mirroring normalize_level.
   fn level_normalize(l: KLevel) -> List‹&NLEntry› {
-    let seed = store(ListNode.Cons(
-      store(NLEntry.Mk(store(ListNode.Nil), 0, store(ListNode.Nil))),
-      store(ListNode.Nil)));
-    let raw = normalize_aux(l, store(ListNode.Nil), 0, seed);
+    let seed = List.Cons(store((
+      store(NLEntry.Mk(List.Nil, 0, List.Nil)),
+      List.Nil)));
+    let raw = normalize_aux(l, List.Nil, 0, seed);
     nl_subsumption_walk(raw, raw)
   }
 
@@ -851,20 +851,20 @@ def levels := ⟦
   }
 
   fn level_list_inst(lvls: List‹KLevel›, params: List‹KLevel›) -> List‹KLevel› {
-    match load(lvls) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(l, rest) =>
-        store(ListNode.Cons(
+    match lvls {
+      List.Nil => List.Nil,
+      List.Cons(__cell27) => let (l, rest) = load(__cell27);
+        List.Cons(store((
           level_inst_params(l, params),
-          level_list_inst(rest, params))),
+          level_list_inst(rest, params)))),
     }
   }
 
   fn expr_inst_levels(e: KExpr, params: List‹KLevel›) -> KExpr {
     -- Fast path: empty param list = identity. Common when caller's lvls
     -- list is Nil (constants with no universe params).
-    match load(params) {
-      ListNode.Nil => e,
+    match params {
+      List.Nil => e,
       _ => expr_inst_levels_walk(e, params),
     }
   }
@@ -898,16 +898,16 @@ def levels := ⟦
   -- ============================================================================
 
   fn klimbs_eq(a: KLimbs, b: KLimbs) -> G {
-    match load(a) {
-      ListNode.Nil =>
-        match load(b) {
-          ListNode.Nil => 1,
+    match a {
+      List.Nil =>
+        match b {
+          List.Nil => 1,
           _ => 0,
         },
-      ListNode.Cons(la, ra) =>
-        match load(b) {
-          ListNode.Nil => 0,
-          ListNode.Cons(lb, rb) =>
+      List.Cons(__cell28) => let (la, ra) = load(__cell28);
+        match b {
+          List.Nil => 0,
+          List.Cons(__cell29) => let (lb, rb) = load(__cell29);
             let eq = u64_eq(la, lb);
             match eq {
               1 => klimbs_eq(ra, rb),
@@ -918,16 +918,16 @@ def levels := ⟦
   }
 
   fn bytestream_eq(a: ByteStream, b: ByteStream) -> G {
-    match load(a) {
-      ListNode.Nil =>
-        match load(b) {
-          ListNode.Nil => 1,
+    match a {
+      List.Nil =>
+        match b {
+          List.Nil => 1,
           _ => 0,
         },
-      ListNode.Cons(ba, ra) =>
-        match load(b) {
-          ListNode.Nil => 0,
-          ListNode.Cons(bb, rb) =>
+      List.Cons(__cell30) => let (ba, ra) = load(__cell30);
+        match b {
+          List.Nil => 0,
+          List.Cons(__cell31) => let (bb, rb) = load(__cell31);
             match to_field(ba) - to_field(bb) {
               0 => bytestream_eq(ra, rb),
               _ => 0,
diff --git a/Ix/IxVM/Kernel/NatPrim.lean b/Ix/IxVM/Kernel/NatPrim.lean
index 8d00a3e4..eab008e2 100644
--- a/Ix/IxVM/Kernel/NatPrim.lean
+++ b/Ix/IxVM/Kernel/NatPrim.lean
@@ -264,14 +264,14 @@ def natPrim := ⟦
   }
 
   fn mk_nat_literal_64() -> KExpr {
-    let limbs = store(ListNode.Cons(
-      [64u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
+    let limbs = List.Cons(store((
+      [64u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], List.Nil)));
     store(KExprNode.Lit(KLiteral.Nat(limbs)))
   }
 
   fn mk_nat_one() -> KExpr {
-    let limbs = store(ListNode.Cons(
-      [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
+    let limbs = List.Cons(store((
+      [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], List.Nil)));
     store(KExprNode.Lit(KLiteral.Nat(limbs)))
   }
 
@@ -444,8 +444,8 @@ def natPrim := ⟦
   -- Bool value (0/1) → Const(Bool.false/Bool.true).
   fn mk_bool(g: G) -> KExpr {
     match g {
-      0 => store(KExprNode.Const(bool_false_addr(), store(ListNode.Nil))),
-      _ => store(KExprNode.Const(bool_true_addr(), store(ListNode.Nil))),
+      0 => store(KExprNode.Const(bool_false_addr(), List.Nil)),
+      _ => store(KExprNode.Const(bool_true_addr(), List.Nil)),
     }
   }
 
@@ -453,17 +453,17 @@ def natPrim := ⟦
   -- (1, N mod 2^W) as KLimbs. (0, _) on miss.
   fn bv_to_nat_via(width_e: KExpr, val_e: KExpr) -> (G, KLimbs) {
     match bitvec_of_nat_args_direct(val_e) {
-      (0, _, _) => (0, store(ListNode.Nil)),
+      (0, _, _) => (0, List.Nil),
       (1, val_width, n_e) =>
         match try_extract_nat(n_e) {
-          (0, _) => (0, store(ListNode.Nil)),
+          (0, _) => (0, List.Nil),
           (1, n_kl) =>
             match try_extract_nat(val_width) {
-              (0, _) => (0, store(ListNode.Nil)),
+              (0, _) => (0, List.Nil),
               (1, w_kl) =>
-                let two = store(ListNode.Cons(
+                let two = List.Cons(store((
                   [2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
-                  store(ListNode.Nil)));
+                  List.Nil)));
                 let modulus = klimbs_pow(two, w_kl);
                 (1, klimbs_normalize(klimbs_mod(n_kl, modulus))),
             },
@@ -523,10 +523,10 @@ def natPrim := ⟦
                                         let width = list_lookup(ty_args, 0);
                                         let lhs = list_lookup(lt_args, 2);
                                         let rhs = list_lookup(lt_args, 3);
-                                        let inner = store(ListNode.Cons(width,
-                                          store(ListNode.Cons(lhs,
-                                            store(ListNode.Cons(rhs,
-                                              store(ListNode.Nil)))))));
+                                        let inner = List.Cons(store((width,
+                                          List.Cons(store((lhs,
+                                            List.Cons(store((rhs,
+                                              List.Nil)))))))));
                                         try_reduce_bit_vec_ult(inner),
                                     },
                                 },
@@ -601,20 +601,20 @@ def natPrim := ⟦
   fn bitvec_prep_spine_ult(spine: List‹KExpr›, types: List‹KExpr›)
                                 -> List‹KExpr› {
     let sw = whnf_spine(spine, types);
-    match load(sw) {
-      ListNode.Nil => sw,
-      ListNode.Cons(width_e, r1) =>
-        match load(r1) {
-          ListNode.Nil => sw,
-          ListNode.Cons(lhs_e, r2) =>
-            match load(r2) {
-              ListNode.Nil => sw,
-              ListNode.Cons(rhs_e, tail) =>
+    match sw {
+      List.Nil => sw,
+      List.Cons(__cell1) => let (width_e, r1) = load(__cell1);
+        match r1 {
+          List.Nil => sw,
+          List.Cons(__cell2) => let (lhs_e, r2) = load(__cell2);
+            match r2 {
+              List.Nil => sw,
+              List.Cons(__cell3) => let (rhs_e, tail) = load(__cell3);
                 let lhs_p = np_whnf_inner_bv(lhs_e, types);
                 let rhs_p = np_whnf_inner_bv(rhs_e, types);
-                store(ListNode.Cons(width_e,
-                  store(ListNode.Cons(lhs_p,
-                    store(ListNode.Cons(rhs_p, tail)))))),
+                List.Cons(store((width_e,
+                  List.Cons(store((lhs_p,
+                    List.Cons(store((rhs_p, tail))))))))),
             },
         },
     }
@@ -866,7 +866,7 @@ def natPrim := ⟦
                 let cp_limbs = klimbs_from_g(cp);
                 let cp_lit = store(KExprNode.Lit(KLiteral.Nat(cp_limbs)));
                 let con = store(KExprNode.Const(char_of_nat_addr(),
-                                                 store(ListNode.Nil)));
+                                                 List.Nil));
                 (1, store(KExprNode.App(con, cp_lit))),
               _ => (0, store(KExprNode.BVar(0))),
             },
@@ -885,10 +885,10 @@ def natPrim := ⟦
           KExprNode.Lit(lit) =>
             match lit {
               KLiteral.Str(bs) =>
-                match load(bs) {
-                  ListNode.Nil =>
+                match bs {
+                  List.Nil =>
                     (1, store(KExprNode.Const(byte_array_empty_addr(),
-                                                store(ListNode.Nil)))),
+                                                List.Nil))),
                   _ => (0, store(KExprNode.BVar(0))),
                 },
               _ => (0, store(KExprNode.BVar(0))),
@@ -911,9 +911,9 @@ def natPrim := ⟦
   -- the bytes, so a literal that is never decoded would otherwise
   -- typecheck as a `String` that no Lean `String` corresponds to.
   fn utf8_validate(bs: ByteStream) {
-    match load(bs) {
-      ListNode.Nil => (),
-      ListNode.Cons(b0, rest) =>
+    match bs {
+      List.Nil => (),
+      List.Cons(__cell4) => let (b0, rest) = load(__cell4);
         match utf8_decode_one(b0, rest) {
           (_, remaining) => utf8_validate(remaining),
         },
@@ -925,9 +925,9 @@ def natPrim := ⟦
   }
 
   fn utf8_last_go(bs: ByteStream, prev: G) -> G {
-    match load(bs) {
-      ListNode.Nil => prev,
-      ListNode.Cons(b0, rest) =>
+    match bs {
+      List.Nil => prev,
+      List.Cons(__cell5) => let (b0, rest) = load(__cell5);
         match utf8_decode_one(b0, rest) {
           (cp, remaining) => utf8_last_go(remaining, cp),
         },
@@ -977,8 +977,8 @@ def natPrim := ⟦
           0 =>
             match u8_less_than(b0, 224u8) {
               1 =>
-                match load(rest) {
-                  ListNode.Cons(b1, r1) =>
+                match rest {
+                  List.Cons(__cell6) => let (b1, r1) = load(__cell6);
                     -- Two-byte cp is >= 0x80 for every leader >= 0xC2, so
                     -- no overlong is reachable once the leader is gated.
                     let cp = (to_field(b0) - 192) * 64 + utf8_cont(b1);
@@ -987,10 +987,10 @@ def natPrim := ⟦
               _ =>
                 match u8_less_than(b0, 240u8) {
                   1 =>
-                    match load(rest) {
-                      ListNode.Cons(b1, r1) =>
-                        match load(r1) {
-                          ListNode.Cons(b2, r2) =>
+                    match rest {
+                      List.Cons(__cell7) => let (b1, r1) = load(__cell7);
+                        match r1 {
+                          List.Cons(__cell8) => let (b2, r2) = load(__cell8);
                             let cp = (to_field(b0) - 224) * 4096
                                    + utf8_cont(b1) * 64
                                    + utf8_cont(b2);
@@ -1004,12 +1004,12 @@ def natPrim := ⟦
                         },
                     },
                   _ =>
-                    match load(rest) {
-                      ListNode.Cons(b1, r1) =>
-                        match load(r1) {
-                          ListNode.Cons(b2, r2) =>
-                            match load(r2) {
-                              ListNode.Cons(b3, r3) =>
+                    match rest {
+                      List.Cons(__cell9) => let (b1, r1) = load(__cell9);
+                        match r1 {
+                          List.Cons(__cell10) => let (b2, r2) = load(__cell10);
+                            match r2 {
+                              List.Cons(__cell11) => let (b3, r3) = load(__cell11);
                                 let cp = (to_field(b0) - 240) * 262144
                                        + utf8_cont(b1) * 4096
                                        + utf8_cont(b2) * 64
@@ -1036,12 +1036,12 @@ def natPrim := ⟦
   -- harness always seeds their bytes.
   fn str_lit_to_ctor(bs: ByteStream) -> KExpr {
     let zero_lvl = store(KLevelNode.Zero);
-    let ulvls = store(ListNode.Cons(zero_lvl, store(ListNode.Nil)));
+    let ulvls = List.Cons(store((zero_lvl, List.Nil)));
     let nil_const = store(KExprNode.Const(list_nil_addr(), ulvls));
     let cons_const = store(KExprNode.Const(list_cons_addr(), ulvls));
-    let char_const = store(KExprNode.Const(char_type_addr(), store(ListNode.Nil)));
-    let con_const = store(KExprNode.Const(char_of_nat_addr(), store(ListNode.Nil)));
-    let str_const = store(KExprNode.Const(string_of_list_addr(), store(ListNode.Nil)));
+    let char_const = store(KExprNode.Const(char_type_addr(), List.Nil));
+    let con_const = store(KExprNode.Const(char_of_nat_addr(), List.Nil));
+    let str_const = store(KExprNode.Const(string_of_list_addr(), List.Nil));
     let nil_app = store(KExprNode.App(nil_const, char_const));
     let cons_partial = store(KExprNode.App(cons_const, char_const));
     let list_expr = build_char_list(bs, nil_app, cons_partial, con_const);
@@ -1050,9 +1050,9 @@ def natPrim := ⟦
 
   fn build_char_list(bs: ByteStream, nil_app: KExpr,
                          cons_partial: KExpr, con_const: KExpr) -> KExpr {
-    match load(bs) {
-      ListNode.Nil => nil_app,
-      ListNode.Cons(b0, rest) =>
+    match bs {
+      List.Nil => nil_app,
+      List.Cons(__cell12) => let (b0, rest) = load(__cell12);
         match utf8_decode_one(b0, rest) {
           (cp, remaining) =>
             let cp_limbs = klimbs_from_g(cp);
@@ -1077,7 +1077,7 @@ def natPrim := ⟦
             let ci = load(get_ci(caddr));
             match ci {
               KConstantInfo.Defn(_, _, value, _, _) =>
-                let body = expr_inst_levels(value, store(ListNode.Nil));
+                let body = expr_inst_levels(value, List.Nil);
                 match load(body) {
                   KExprNode.Lam(_, lam_body) =>
                     whnf_nd(expr_inst1(lam_body, list_arg, 0), types),
@@ -1139,8 +1139,8 @@ def natPrim := ⟦
         assert_eq!(x, to_field(b0) + 256 * to_field(b1)
                    + 65536 * to_field(b2) + 16777216 * to_field(b3),
           "u32 byte split does not recompose to the original value");
-        store(ListNode.Cons([b0, b1, b2, b3, 0u8, 0u8, 0u8, 0u8],
-                            store(ListNode.Nil))),
+        List.Cons(store(([b0, b1, b2, b3, 0u8, 0u8, 0u8, 0u8],
+                            List.Nil))),
     }
   }
 
@@ -1158,28 +1158,28 @@ def natPrim := ⟦
             match address_eq(caddr, list_nil_addr()) {
               1 =>
                 match list_length(args) {
-                  1 => (1, store(ListNode.Nil)),
-                  _ => (0, store(ListNode.Nil)),
+                  1 => (1, List.Nil),
+                  _ => (0, List.Nil),
                 },
               _ =>
                 match address_eq(caddr, list_cons_addr()) {
-                  0 => (0, store(ListNode.Nil)),
+                  0 => (0, List.Nil),
                   _ =>
                     match list_length(args) {
                       3 =>
                         match char_lit_codepoint(list_lookup(args, 1), types) {
-                          (0, _) => (0, store(ListNode.Nil)),
+                          (0, _) => (0, List.Nil),
                           (1, cp) =>
                             match walk_char_list_bytes(list_lookup(args, 2), types) {
                               (0, t) => (0, t),
                               (1, t) => (1, utf8_encode_prepend(cp, t)),
                             },
                         },
-                      _ => (0, store(ListNode.Nil)),
+                      _ => (0, List.Nil),
                     },
                 },
             },
-          _ => (0, store(ListNode.Nil)),
+          _ => (0, List.Nil),
         },
     }
   }
@@ -1223,10 +1223,10 @@ def natPrim := ⟦
   -- to valid Unicode scalars (rejects surrogates 0xD800-0xDFFF and
   -- codepoints ≥ 0x110000).
   fn klimbs_scalar_value(limbs: KLimbs) -> (G, G) {
-    match load(limbs) {
-      ListNode.Cons(limb, rest) =>
-        match load(rest) {
-          ListNode.Nil =>
+    match limbs {
+      List.Cons(__cell13) => let (limb, rest) = load(__cell13);
+        match rest {
+          List.Nil =>
             let [b0, b1, b2, b3, b4, b5, b6, b7] = limb;
             let hi = to_field(b3) + to_field(b4) + to_field(b5) + to_field(b6) + to_field(b7);
             match eq_zero(hi) {
@@ -1301,26 +1301,26 @@ def natPrim := ⟦
         assert_eq!(cp, f0 + f1 * 64 + f2 * 4096 + f3 * 262144,
           "utf8 groups do not recompose to the codepoint");
         match u32_less_than(cp, 128) {
-          1 => store(ListNode.Cons(u8_from_field_unsafe(cp), tail)),
+          1 => List.Cons(store((u8_from_field_unsafe(cp), tail))),
           _ =>
             match u32_less_than(cp, 2048) {
               1 =>
                 let t1 = u8_from_field_unsafe(f0 + 128);
                 let l1 = u8_from_field_unsafe(f1 + 192);
-                store(ListNode.Cons(l1, store(ListNode.Cons(t1, tail)))),
+                List.Cons(store((l1, List.Cons(store((t1, tail)))))),
               _ =>
                 match u32_less_than(cp, 65536) {
                   1 =>
                     let t2 = u8_from_field_unsafe(f0 + 128);
                     let t1 = u8_from_field_unsafe(f1 + 128);
                     let l2 = u8_from_field_unsafe(f2 + 224);
-                    store(ListNode.Cons(l2, store(ListNode.Cons(t1, store(ListNode.Cons(t2, tail)))))),
+                    List.Cons(store((l2, List.Cons(store((t1, List.Cons(store((t2, tail))))))))),
                   _ =>
                     let t3 = u8_from_field_unsafe(f0 + 128);
                     let t2 = u8_from_field_unsafe(f1 + 128);
                     let t1 = u8_from_field_unsafe(f2 + 128);
                     let l3 = u8_from_field_unsafe(f3 + 240);
-                    store(ListNode.Cons(l3, store(ListNode.Cons(t1, store(ListNode.Cons(t2, store(ListNode.Cons(t3, tail)))))))),
+                    List.Cons(store((l3, List.Cons(store((t1, List.Cons(store((t2, List.Cons(store((t3, tail)))))))))))),
                 },
             },
         },
@@ -1405,15 +1405,15 @@ def natPrim := ⟦
       KExprNode.Lit(lit) =>
         match lit {
           KLiteral.Nat(limbs) => (1, limbs),
-          _ => (0, store(ListNode.Nil)),
+          _ => (0, List.Nil),
         },
       KExprNode.Const(caddr, _) =>
         match address_eq(caddr, nat_zero_addr()) {
-          1 => (1, store(ListNode.Nil)),
-          _ => (0, store(ListNode.Nil)),
+          1 => (1, List.Nil),
+          _ => (0, List.Nil),
         },
       KExprNode.App(f, a) => try_extract_nat_app(f, a),
-      _ => (0, store(ListNode.Nil)),
+      _ => (0, List.Nil),
     }
   }
 
@@ -1427,11 +1427,11 @@ def natPrim := ⟦
           1 =>
             match try_extract_nat(a) {
               (1, pred_limbs) => (1, klimbs_succ(pred_limbs)),
-              _ => (0, store(ListNode.Nil)),
+              _ => (0, List.Nil),
             },
-          _ => (0, store(ListNode.Nil)),
+          _ => (0, List.Nil),
         },
-      _ => (0, store(ListNode.Nil)),
+      _ => (0, List.Nil),
     }
   }
 
@@ -1443,9 +1443,9 @@ def natPrim := ⟦
   -- Apply spine (rebuild App chain).
   -- ============================================================================
   fn np_apply_spine(head: KExpr, spine: List‹KExpr›) -> KExpr {
-    match load(spine) {
-      ListNode.Nil => head,
-      ListNode.Cons(a, rest) =>
+    match spine {
+      List.Nil => head,
+      List.Cons(__cell14) => let (a, rest) = load(__cell14);
         np_apply_spine(store(KExprNode.App(head, a)), rest),
     }
   }
@@ -1522,7 +1522,7 @@ def natPrim := ⟦
     match load(head) {
       KExprNode.Const(caddr, _) =>
         match address_eq(caddr, nat_add_addr()) {
-          0 => (0, head, store(ListNode.Nil)),
+          0 => (0, head, List.Nil),
           _ =>
             match list_length(args) - 2 {
               0 =>
@@ -1532,28 +1532,28 @@ def natPrim := ⟦
                   KExprNode.Lit(lit) =>
                     match lit {
                       KLiteral.Nat(limbs) => (1, lhs, limbs),
-                      _ => (0, head, store(ListNode.Nil)),
+                      _ => (0, head, List.Nil),
                     },
-                  _ => (0, head, store(ListNode.Nil)),
+                  _ => (0, head, List.Nil),
                 },
-              _ => (0, head, store(ListNode.Nil)),
+              _ => (0, head, List.Nil),
             },
         },
-      _ => (0, head, store(ListNode.Nil)),
+      _ => (0, head, List.Nil),
     }
   }
 
   -- Build `Nat.succ pred` where pred = base if lit==1,
   -- else `Nat.add base (Lit lit-1)`.
   fn build_succ_offset(base: KExpr, lit: KLimbs) -> KExpr {
-    let one = store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
-                                  store(ListNode.Nil)));
+    let one = List.Cons(store(([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
+                                  List.Nil)));
     let pred_lit_norm = klimbs_normalize(klimbs_sub(lit, one));
-    let succ_const = store(KExprNode.Const(nat_succ_addr(), store(ListNode.Nil)));
+    let succ_const = store(KExprNode.Const(nat_succ_addr(), List.Nil));
     match klimbs_is_zero(pred_lit_norm) {
       1 => store(KExprNode.App(succ_const, base)),
       _ =>
-        let add_const = store(KExprNode.Const(nat_add_addr(), store(ListNode.Nil)));
+        let add_const = store(KExprNode.Const(nat_add_addr(), List.Nil));
         let pred_lit_expr = store(KExprNode.Lit(KLiteral.Nat(pred_lit_norm)));
         let pred = store(KExprNode.App(
           store(KExprNode.App(add_const, base)),
@@ -1598,7 +1598,7 @@ def natPrim := ⟦
     match klimbs_is_zero(n) {
       1 => (1, np_apply_spine(base_w, post)),
       _ =>
-        let add_const = store(KExprNode.Const(nat_add_addr(), store(ListNode.Nil)));
+        let add_const = store(KExprNode.Const(nat_add_addr(), List.Nil));
         let off = store(KExprNode.App(
           store(KExprNode.App(add_const, base_w)),
           mk_nat_lit(n)));
@@ -1784,7 +1784,7 @@ def natPrim := ⟦
   -- Mirror mk_nat_binop_stuck (Primitive.lean:1750), addr-first.
   fn mk_nat_binop_stuck(op_addr: Addr, base_w: KExpr, n: KLimbs,
                              post: List‹KExpr›) -> KExpr {
-    let op_const = store(KExprNode.Const(op_addr, store(ListNode.Nil)));
+    let op_const = store(KExprNode.Const(op_addr, List.Nil));
     let stuck = store(KExprNode.App(
       store(KExprNode.App(op_const, base_w)),
       mk_nat_lit(n)));
diff --git a/Ix/IxVM/Kernel/Subst.lean b/Ix/IxVM/Kernel/Subst.lean
index b55ca08f..b2668e46 100644
--- a/Ix/IxVM/Kernel/Subst.lean
+++ b/Ix/IxVM/Kernel/Subst.lean
@@ -200,7 +200,7 @@ def subst := ⟦
 
   -- Smallest valid cut ≥ 1 of the stack headed at `types` (nonempty).
   fn ctx_next_cut(types: List‹KExpr›) -> G {
-    let ListNode.Cons(ty, rest) = load(types);
+    let List.Cons(__lcell1001) = types; let (ty, rest) = load(__lcell1001);
     1 + ctx_close_cut(rest, expr_lbr(ty))
   }
 
@@ -223,7 +223,7 @@ def subst := ⟦
   -- `base >= len` → nothing to trim. Only partially-open exprs pay the scan.
   fn ctx_trim(types: List‹KExpr›, base: G) -> List‹KExpr› {
     match base {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ =>
         match u32_less_than(base, list_length(types)) {
           0 => types,
diff --git a/Ix/IxVM/Kernel/Whnf.lean b/Ix/IxVM/Kernel/Whnf.lean
index 9ee51704..7c6215c4 100644
--- a/Ix/IxVM/Kernel/Whnf.lean
+++ b/Ix/IxVM/Kernel/Whnf.lean
@@ -32,9 +32,9 @@ rule and structure eta.
 
 def whnf := ⟦
   fn apply_spine(head: KExpr, spine: List‹KExpr›) -> KExpr {
-    match load(spine) {
-      ListNode.Nil => head,
-      ListNode.Cons(a, rest) =>
+    match spine {
+      List.Nil => head,
+      List.Cons(__cell1) => let (a, rest) = load(__cell1);
         apply_spine(store(KExprNode.App(head, a)), rest),
     }
   }
@@ -44,10 +44,10 @@ def whnf := ⟦
                   -> (KExpr, List‹KExpr›, List‹KExpr›) {
     match load(lam) {
       KExprNode.Lam(_, body) =>
-        match load(spine) {
-          ListNode.Cons(a, rest) =>
-            peel_beta(body, rest, store(ListNode.Cons(a, acc))),
-          ListNode.Nil => (lam, acc, spine),
+        match spine {
+          List.Cons(__cell2) => let (a, rest) = load(__cell2);
+            peel_beta(body, rest, List.Cons(store((a, acc)))),
+          List.Nil => (lam, acc, spine),
         },
       _ => (lam, acc, spine),
     }
@@ -58,7 +58,7 @@ def whnf := ⟦
   -- instead of one `expr_inst1` re-walk of the body per arg. Single-arg betas
   -- stay on the cheap `expr_inst1` path (no list overhead).
   fn whnf_apply_beta(spine: List‹KExpr›, lam: KExpr, types: List‹KExpr›) -> KExpr {
-    match peel_beta(lam, spine, store(ListNode.Nil)) {
+    match peel_beta(lam, spine, List.Nil) {
       (deep, consumed, rest) =>
         match list_length(consumed) {
           0 => apply_spine(lam, spine),
@@ -217,7 +217,7 @@ def whnf := ⟦
                                     let true_minor = store(KExprNode.Lam(
                                       tdom, tproj));
                                     let nat_ty = store(KExprNode.Const(
-                                      nat_ty_addr(), store(ListNode.Nil)));
+                                      nat_ty_addr(), List.Nil));
                                     let new_motive = store(KExprNode.Lam(
                                       motive_dom, nat_ty));
                                     let head_const = store(KExprNode.Const(
@@ -261,11 +261,11 @@ def whnf := ⟦
   -- WHNF each spine arg (needed before calling nat dispatch — args
   -- must be normalized to Lit/Const-headed forms for try_extract_nat).
   fn whnf_spine(spine: List‹KExpr›, types: List‹KExpr›) -> List‹KExpr› {
-    match load(spine) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(a, rest) =>
+    match spine {
+      List.Nil => List.Nil,
+      List.Cons(__cell3) => let (a, rest) = load(__cell3);
         let aw = whnf(a, types);
-        store(ListNode.Cons(aw, whnf_spine(rest, types))),
+        List.Cons(store((aw, whnf_spine(rest, types)))),
     }
   }
 
@@ -290,19 +290,19 @@ def whnf := ⟦
   fn bitvec_prep_spine(spine: List‹KExpr›, types: List‹KExpr›)
                             -> List‹KExpr› {
     let spine_w = whnf_spine(spine, types);
-    match load(spine_w) {
-      ListNode.Nil => spine_w,
-      ListNode.Cons(width_e, rest) =>
-        match load(rest) {
-          ListNode.Nil => spine_w,
-          ListNode.Cons(val_e, tail) =>
+    match spine_w {
+      List.Nil => spine_w,
+      List.Cons(__cell4) => let (width_e, rest) = load(__cell4);
+        match rest {
+          List.Nil => spine_w,
+          List.Cons(__cell5) => let (val_e, tail) = load(__cell5);
             match collect_spine(val_e) {
               (vh, va) =>
                 let va_w = whnf_spine(va, types);
                 let val_e2 = apply_spine(vh, va_w);
                 let width_w = whnf(width_e, types);
-                store(ListNode.Cons(width_w,
-                  store(ListNode.Cons(val_e2, tail)))),
+                List.Cons(store((width_w,
+                  List.Cons(store((val_e2, tail)))))),
             },
         },
     }
@@ -630,12 +630,12 @@ def whnf := ⟦
           KLiteral.Nat(klimbs) =>
             match klimbs_is_zero(klimbs) {
               1 => store(KExprNode.Const(nat_zero_addr_iota(),
-                                          store(ListNode.Nil))),
+                                          List.Nil)),
               _ =>
                 let pred_limbs = klimbs_normalize(klimbs_dec(klimbs));
                 let pred = store(KExprNode.Lit(KLiteral.Nat(pred_limbs)));
                 let succ_const = store(KExprNode.Const(nat_succ_addr_iota(),
-                                                       store(ListNode.Nil)));
+                                                       List.Nil));
                 store(KExprNode.App(succ_const, pred)),
             },
           _ => e,
@@ -662,8 +662,8 @@ def whnf := ⟦
                           rules: List‹KRecRule›,
                           rec_parent: Addr, types: List‹KExpr›)
                           -> (G, KExpr) {
-    match load(rules) {
-      ListNode.Cons(r, _) =>
+    match rules {
+      List.Cons(__cell6) => let (r, _) = load(__cell6);
         match r {
           KRecRule.Mk(cidx, _rfields, rrhs) =>
             let major_idx = nparams + nmotives + nminors + nindices;
@@ -748,7 +748,7 @@ def whnf := ⟦
     let pre = list_take(spine, major_idx);
     let post = list_drop(spine, major_idx + 1);
     let with_major = list_concat(pre,
-      store(ListNode.Cons(major_w, store(ListNode.Nil))));
+      List.Cons(store((major_w, List.Nil))));
     list_concat(with_major, post)
   }
 
@@ -871,18 +871,18 @@ def whnf := ⟦
             match ci {
               KConstantInfo.Ctor(_, _, block_addr, ind_idx, cidx, _, _, _) =>
                 (1, cidx, compute_iprj_addr(block_addr, ind_idx), args),
-              _ => (0, 0, store([0u8; 32]), store(ListNode.Nil)),
+              _ => (0, 0, store([0u8; 32]), List.Nil),
             },
-          _ => (0, 0, store([0u8; 32]), store(ListNode.Nil)),
+          _ => (0, 0, store([0u8; 32]), List.Nil),
         },
     }
   }
 
   -- Find rule matching cidx: returns (1, nfields, rhs) or (0, 0, ...).
   fn find_rule(rules: List‹KRecRule›, cidx: G) -> (G, G, KExpr) {
-    match load(rules) {
-      ListNode.Nil => (0, 0, store(KExprNode.BVar(0))),
-      ListNode.Cons(r, rest) =>
+    match rules {
+      List.Nil => (0, 0, store(KExprNode.BVar(0))),
+      List.Cons(__cell7) => let (r, rest) = load(__cell7);
         match r {
           KRecRule.Mk(rcidx, nfields, rhs) =>
             match rcidx - cidx {
@@ -910,12 +910,12 @@ def whnf := ⟦
                                nminors: G, nindices: G,
                                rules: List‹KRecRule›,
                                types: List‹KExpr›) -> (G, KExpr) {
-    match load(rules) {
-      ListNode.Nil => (0, store(KExprNode.BVar(0))),
-      ListNode.Cons(r, rest) =>
-        match load(rest) {
-          ListNode.Cons(_, _) => (0, store(KExprNode.BVar(0))),
-          ListNode.Nil =>
+    match rules {
+      List.Nil => (0, store(KExprNode.BVar(0))),
+      List.Cons(__cell8) => let (r, rest) = load(__cell8);
+        match rest {
+          List.Cons(_) => (0, store(KExprNode.BVar(0))),
+          List.Nil =>
             match r {
               KRecRule.Mk(_, nf, rhs) =>
                 let skip = ((nparams + nmotives) + nminors) + nindices;
@@ -1016,7 +1016,7 @@ def whnf := ⟦
       Constant.Mk(info, _, _, _) =>
         match info {
           ConstantInfo.Muts(members) => build_recur_addrs(members, block),
-          _ => store(ListNode.Cons(parent, store(ListNode.Nil))),
+          _ => List.Cons(store((parent, List.Nil))),
         },
     }
   }
@@ -1095,9 +1095,9 @@ def whnf := ⟦
   }
 
   fn se_addr_in(a: Addr, xs: List‹Addr›) -> G {
-    match load(xs) {
-      ListNode.Nil => 0,
-      ListNode.Cons(x, rest) =>
+    match xs {
+      List.Nil => 0,
+      List.Cons(__cell9) => let (x, rest) = load(__cell9);
         match address_eq(a, x) {
           1 => 1,
           _ => se_addr_in(a, rest),
@@ -1119,7 +1119,7 @@ def whnf := ⟦
   }
 
   fn whnf_core(e: KExpr, types: List‹KExpr›) -> KExpr {
-    whnf_with_spine(e, store(ListNode.Nil), types)
+    whnf_with_spine(e, List.Nil, types)
   }
 
   -- ============================================================================
@@ -1146,7 +1146,7 @@ def whnf := ⟦
   }
 
   fn whnf_nd_core(e: KExpr, types: List‹KExpr›) -> KExpr {
-    whnf_nd_with_spine(e, store(ListNode.Nil), types)
+    whnf_nd_with_spine(e, List.Nil, types)
   }
 
   fn whnf_nd_with_spine(head: KExpr, spine: List‹KExpr›,
@@ -1172,7 +1172,7 @@ def whnf := ⟦
 
   fn whnf_nd_apply_beta(spine: List‹KExpr›, lam: KExpr,
                             types: List‹KExpr›) -> KExpr {
-    match peel_beta(lam, spine, store(ListNode.Nil)) {
+    match peel_beta(lam, spine, List.Nil) {
       (deep, consumed, rest) =>
         match list_length(consumed) {
           0 => apply_spine(lam, spine),
diff --git a/Ix/IxVM/KernelTypes.lean b/Ix/IxVM/KernelTypes.lean
index e51160bb..9cef3ee1 100644
--- a/Ix/IxVM/KernelTypes.lean
+++ b/Ix/IxVM/KernelTypes.lean
@@ -68,7 +68,7 @@ def kernelTypes := ⟦
       KExprNode.App(f, a) =>
         let (head, args) = collect_spine(f);
         (head, list_snoc(args, a)),
-      _ => (e, store(ListNode.Nil)),
+      _ => (e, List.Nil),
     }
   }
 
diff --git a/Ix/IxVM/Sha256.lean b/Ix/IxVM/Sha256.lean
index ca2b9085..b884831b 100644
--- a/Ix/IxVM/Sha256.lean
+++ b/Ix/IxVM/Sha256.lean
@@ -46,476 +46,476 @@ def sha256 := ⟦
 
   fn sha256_aux(stream: ByteStream, len_be: U64, state: [[U8; 4]; 8]) -> [[U8; 4]; 8] {
     let W = [[0u8; 4]; 16];
-    match load(stream) {
-      ListNode.Nil =>
+    match stream {
+      List.Nil =>
         let W = set(W, 0, [0x80u8, 0u8, 0u8, 0u8]);
         let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
         let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
         fill_W_and_run_rounds(W, state),
-      ListNode.Cons(b0, tail) => match load(tail) {
-        ListNode.Nil =>
+      List.Cons(__cell1) => let (b0, tail) = load(__cell1); match tail {
+        List.Nil =>
           let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 8u8]);
           let W = set(W, 0, [b0, 0x80u8, 0u8, 0u8]);
           let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
           let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
           fill_W_and_run_rounds(W, state),
-        ListNode.Cons(b1, tail) => match load(tail) {
-          ListNode.Nil =>
+        List.Cons(__cell2) => let (b1, tail) = load(__cell2); match tail {
+          List.Nil =>
             let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 16u8]);
             let W = set(W, 0, [b0, b1, 0x80u8, 0u8]);
             let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
             let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
             fill_W_and_run_rounds(W, state),
-          ListNode.Cons(b2, tail) => match load(tail) {
-            ListNode.Nil =>
+          List.Cons(__cell3) => let (b2, tail) = load(__cell3); match tail {
+            List.Nil =>
               let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 24u8]);
               let W = set(W, 0, [b0, b1, b2, 0x80u8]);
               let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
               let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
               fill_W_and_run_rounds(W, state),
-            ListNode.Cons(b3, tail) =>
+            List.Cons(__cell4) => let (b3, tail) = load(__cell4);
               let W = set(W, 0, [b0, b1, b2, b3]);
-              match load(tail) {
-              ListNode.Nil =>
+              match tail {
+              List.Nil =>
                 let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 32u8]);
                 let W = set(W, 1, [0x80u8, 0u8, 0u8, 0u8]);
                 let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                 let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                 fill_W_and_run_rounds(W, state),
-              ListNode.Cons(b4, tail) => match load(tail) {
-                ListNode.Nil =>
+              List.Cons(__cell5) => let (b4, tail) = load(__cell5); match tail {
+                List.Nil =>
                   let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 40u8]);
                   let W = set(W, 1, [b4, 0x80u8, 0u8, 0u8]);
                   let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                   let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                   fill_W_and_run_rounds(W, state),
-                ListNode.Cons(b5, tail) => match load(tail) {
-                  ListNode.Nil =>
+                List.Cons(__cell6) => let (b5, tail) = load(__cell6); match tail {
+                  List.Nil =>
                     let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 48u8]);
                     let W = set(W, 1, [b4, b5, 0x80u8, 0u8]);
                     let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                     let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                     fill_W_and_run_rounds(W, state),
-                  ListNode.Cons(b6, tail) => match load(tail) {
-                    ListNode.Nil =>
+                  List.Cons(__cell7) => let (b6, tail) = load(__cell7); match tail {
+                    List.Nil =>
                       let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 56u8]);
                       let W = set(W, 1, [b4, b5, b6, 0x80u8]);
                       let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                       let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                       fill_W_and_run_rounds(W, state),
-                    ListNode.Cons(b7, tail) =>
+                    List.Cons(__cell8) => let (b7, tail) = load(__cell8);
                       let W = set(W, 1, [b4, b5, b6, b7]);
-                      match load(tail) {
-                      ListNode.Nil =>
+                      match tail {
+                      List.Nil =>
                         let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 64u8]);
                         let W = set(W, 2, [0x80u8, 0u8, 0u8, 0u8]);
                         let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                         let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                         fill_W_and_run_rounds(W, state),
-                      ListNode.Cons(b8, tail) => match load(tail) {
-                        ListNode.Nil =>
+                      List.Cons(__cell9) => let (b8, tail) = load(__cell9); match tail {
+                        List.Nil =>
                           let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 72u8]);
                           let W = set(W, 2, [b8, 0x80u8, 0u8, 0u8]);
                           let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                           let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                           fill_W_and_run_rounds(W, state),
-                        ListNode.Cons(b9, tail) => match load(tail) {
-                          ListNode.Nil =>
+                        List.Cons(__cell10) => let (b9, tail) = load(__cell10); match tail {
+                          List.Nil =>
                             let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 80u8]);
                             let W = set(W, 2, [b8, b9, 0x80u8, 0u8]);
                             let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                             let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                             fill_W_and_run_rounds(W, state),
-                          ListNode.Cons(b10, tail) => match load(tail) {
-                            ListNode.Nil =>
+                          List.Cons(__cell11) => let (b10, tail) = load(__cell11); match tail {
+                            List.Nil =>
                               let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 88u8]);
                               let W = set(W, 2, [b8, b9, b10, 0x80u8]);
                               let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                               let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                               fill_W_and_run_rounds(W, state),
-                            ListNode.Cons(b11, tail) =>
+                            List.Cons(__cell12) => let (b11, tail) = load(__cell12);
                               let W = set(W, 2, [b8, b9, b10, b11]);
-                              match load(tail) {
-                              ListNode.Nil =>
+                              match tail {
+                              List.Nil =>
                                 let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 96u8]);
                                 let W = set(W, 3, [0x80u8, 0u8, 0u8, 0u8]);
                                 let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                 let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                 fill_W_and_run_rounds(W, state),
-                              ListNode.Cons(b12, tail) => match load(tail) {
-                                ListNode.Nil =>
+                              List.Cons(__cell13) => let (b12, tail) = load(__cell13); match tail {
+                                List.Nil =>
                                   let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 104u8]);
                                   let W = set(W, 3, [b12, 0x80u8, 0u8, 0u8]);
                                   let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                   let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                   fill_W_and_run_rounds(W, state),
-                                ListNode.Cons(b13, tail) => match load(tail) {
-                                  ListNode.Nil =>
+                                List.Cons(__cell14) => let (b13, tail) = load(__cell14); match tail {
+                                  List.Nil =>
                                     let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 112u8]);
                                     let W = set(W, 3, [b12, b13, 0x80u8, 0u8]);
                                     let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                     let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                     fill_W_and_run_rounds(W, state),
-                                  ListNode.Cons(b14, tail) => match load(tail) {
-                                    ListNode.Nil =>
+                                  List.Cons(__cell15) => let (b14, tail) = load(__cell15); match tail {
+                                    List.Nil =>
                                       let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 120u8]);
                                       let W = set(W, 3, [b12, b13, b14, 0x80u8]);
                                       let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                       let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                       fill_W_and_run_rounds(W, state),
-                                    ListNode.Cons(b15, tail) =>
+                                    List.Cons(__cell16) => let (b15, tail) = load(__cell16);
                                       let W = set(W, 3, [b12, b13, b14, b15]);
-                                      match load(tail) {
-                                      ListNode.Nil =>
+                                      match tail {
+                                      List.Nil =>
                                         let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 128u8]);
                                         let W = set(W, 4, [0x80u8, 0u8, 0u8, 0u8]);
                                         let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                         let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                         fill_W_and_run_rounds(W, state),
-                                      ListNode.Cons(b16, tail) => match load(tail) {
-                                        ListNode.Nil =>
+                                      List.Cons(__cell17) => let (b16, tail) = load(__cell17); match tail {
+                                        List.Nil =>
                                           let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 136u8]);
                                           let W = set(W, 4, [b16, 0x80u8, 0u8, 0u8]);
                                           let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                           let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                           fill_W_and_run_rounds(W, state),
-                                        ListNode.Cons(b17, tail) => match load(tail) {
-                                          ListNode.Nil =>
+                                        List.Cons(__cell18) => let (b17, tail) = load(__cell18); match tail {
+                                          List.Nil =>
                                             let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 144u8]);
                                             let W = set(W, 4, [b16, b17, 0x80u8, 0u8]);
                                             let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                             let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                             fill_W_and_run_rounds(W, state),
-                                          ListNode.Cons(b18, tail) => match load(tail) {
-                                            ListNode.Nil =>
+                                          List.Cons(__cell19) => let (b18, tail) = load(__cell19); match tail {
+                                            List.Nil =>
                                               let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 152u8]);
                                               let W = set(W, 4, [b16, b17, b18, 0x80u8]);
                                               let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                               let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                               fill_W_and_run_rounds(W, state),
-                                            ListNode.Cons(b19, tail) =>
+                                            List.Cons(__cell20) => let (b19, tail) = load(__cell20);
                                               let W = set(W, 4, [b16, b17, b18, b19]);
-                                              match load(tail) {
-                                              ListNode.Nil =>
+                                              match tail {
+                                              List.Nil =>
                                                 let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 160u8]);
                                                 let W = set(W, 5, [0x80u8, 0u8, 0u8, 0u8]);
                                                 let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                 let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                 fill_W_and_run_rounds(W, state),
-                                              ListNode.Cons(b20, tail) => match load(tail) {
-                                                ListNode.Nil =>
+                                              List.Cons(__cell21) => let (b20, tail) = load(__cell21); match tail {
+                                                List.Nil =>
                                                   let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 168u8]);
                                                   let W = set(W, 5, [b20, 0x80u8, 0u8, 0u8]);
                                                   let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                   let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                   fill_W_and_run_rounds(W, state),
-                                                ListNode.Cons(b21, tail) => match load(tail) {
-                                                  ListNode.Nil =>
+                                                List.Cons(__cell22) => let (b21, tail) = load(__cell22); match tail {
+                                                  List.Nil =>
                                                     let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 176u8]);
                                                     let W = set(W, 5, [b20, b21, 0x80u8, 0u8]);
                                                     let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                     let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                     fill_W_and_run_rounds(W, state),
-                                                  ListNode.Cons(b22, tail) => match load(tail) {
-                                                    ListNode.Nil =>
+                                                  List.Cons(__cell23) => let (b22, tail) = load(__cell23); match tail {
+                                                    List.Nil =>
                                                       let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 184u8]);
                                                       let W = set(W, 5, [b20, b21, b22, 0x80u8]);
                                                       let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                       let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                       fill_W_and_run_rounds(W, state),
-                                                    ListNode.Cons(b23, tail) =>
+                                                    List.Cons(__cell24) => let (b23, tail) = load(__cell24);
                                                       let W = set(W, 5, [b20, b21, b22, b23]);
-                                                      match load(tail) {
-                                                      ListNode.Nil =>
+                                                      match tail {
+                                                      List.Nil =>
                                                         let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 192u8]);
                                                         let W = set(W, 6, [0x80u8, 0u8, 0u8, 0u8]);
                                                         let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                         let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                         fill_W_and_run_rounds(W, state),
-                                                      ListNode.Cons(b24, tail) => match load(tail) {
-                                                        ListNode.Nil =>
+                                                      List.Cons(__cell25) => let (b24, tail) = load(__cell25); match tail {
+                                                        List.Nil =>
                                                           let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 200u8]);
                                                           let W = set(W, 6, [b24, 0x80u8, 0u8, 0u8]);
                                                           let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                           let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                           fill_W_and_run_rounds(W, state),
-                                                        ListNode.Cons(b25, tail) => match load(tail) {
-                                                          ListNode.Nil =>
+                                                        List.Cons(__cell26) => let (b25, tail) = load(__cell26); match tail {
+                                                          List.Nil =>
                                                             let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 208u8]);
                                                             let W = set(W, 6, [b24, b25, 0x80u8, 0u8]);
                                                             let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                             let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                             fill_W_and_run_rounds(W, state),
-                                                          ListNode.Cons(b26, tail) => match load(tail) {
-                                                            ListNode.Nil =>
+                                                          List.Cons(__cell27) => let (b26, tail) = load(__cell27); match tail {
+                                                            List.Nil =>
                                                               let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 216u8]);
                                                               let W = set(W, 6, [b24, b25, b26, 0x80u8]);
                                                               let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                               let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                               fill_W_and_run_rounds(W, state),
-                                                            ListNode.Cons(b27, tail) =>
+                                                            List.Cons(__cell28) => let (b27, tail) = load(__cell28);
                                                               let W = set(W, 6, [b24, b25, b26, b27]);
-                                                              match load(tail) {
-                                                              ListNode.Nil =>
+                                                              match tail {
+                                                              List.Nil =>
                                                                 let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 224u8]);
                                                                 let W = set(W, 7, [0x80u8, 0u8, 0u8, 0u8]);
                                                                 let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                 let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                 fill_W_and_run_rounds(W, state),
-                                                              ListNode.Cons(b28, tail) => match load(tail) {
-                                                                ListNode.Nil =>
+                                                              List.Cons(__cell29) => let (b28, tail) = load(__cell29); match tail {
+                                                                List.Nil =>
                                                                   let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 232u8]);
                                                                   let W = set(W, 7, [b28, 0x80u8, 0u8, 0u8]);
                                                                   let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                   let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                   fill_W_and_run_rounds(W, state),
-                                                                ListNode.Cons(b29, tail) => match load(tail) {
-                                                                  ListNode.Nil =>
+                                                                List.Cons(__cell30) => let (b29, tail) = load(__cell30); match tail {
+                                                                  List.Nil =>
                                                                     let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 240u8]);
                                                                     let W = set(W, 7, [b28, b29, 0x80u8, 0u8]);
                                                                     let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                     let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                     fill_W_and_run_rounds(W, state),
-                                                                  ListNode.Cons(b30, tail) => match load(tail) {
-                                                                    ListNode.Nil =>
+                                                                  List.Cons(__cell31) => let (b30, tail) = load(__cell31); match tail {
+                                                                    List.Nil =>
                                                                       let len_be = relaxed_u64_be_add_2_bytes(len_be, [0u8, 248u8]);
                                                                       let W = set(W, 7, [b28, b29, b30, 0x80u8]);
                                                                       let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                       let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                       fill_W_and_run_rounds(W, state),
-                                                                    ListNode.Cons(b31, tail) =>
+                                                                    List.Cons(__cell32) => let (b31, tail) = load(__cell32);
                                                                       let W = set(W, 7, [b28, b29, b30, b31]);
-                                                                      match load(tail) {
-                                                                      ListNode.Nil =>
+                                                                      match tail {
+                                                                      List.Nil =>
                                                                         let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 0u8]);
                                                                         let W = set(W, 8, [0x80u8, 0u8, 0u8, 0u8]);
                                                                         let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                         let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                         fill_W_and_run_rounds(W, state),
-                                                                      ListNode.Cons(b32, tail) => match load(tail) {
-                                                                        ListNode.Nil =>
+                                                                      List.Cons(__cell33) => let (b32, tail) = load(__cell33); match tail {
+                                                                        List.Nil =>
                                                                           let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 8u8]);
                                                                           let W = set(W, 8, [b32, 0x80u8, 0u8, 0u8]);
                                                                           let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                           let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                           fill_W_and_run_rounds(W, state),
-                                                                        ListNode.Cons(b33, tail) => match load(tail) {
-                                                                          ListNode.Nil =>
+                                                                        List.Cons(__cell34) => let (b33, tail) = load(__cell34); match tail {
+                                                                          List.Nil =>
                                                                             let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 16u8]);
                                                                             let W = set(W, 8, [b32, b33, 0x80u8, 0u8]);
                                                                             let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                             let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                             fill_W_and_run_rounds(W, state),
-                                                                          ListNode.Cons(b34, tail) => match load(tail) {
-                                                                            ListNode.Nil =>
+                                                                          List.Cons(__cell35) => let (b34, tail) = load(__cell35); match tail {
+                                                                            List.Nil =>
                                                                               let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 24u8]);
                                                                               let W = set(W, 8, [b32, b33, b34, 0x80u8]);
                                                                               let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                               let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                               fill_W_and_run_rounds(W, state),
-                                                                            ListNode.Cons(b35, tail) =>
+                                                                            List.Cons(__cell36) => let (b35, tail) = load(__cell36);
                                                                               let W = set(W, 8, [b32, b33, b34, b35]);
-                                                                              match load(tail) {
-                                                                              ListNode.Nil =>
+                                                                              match tail {
+                                                                              List.Nil =>
                                                                                 let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 32u8]);
                                                                                 let W = set(W, 9, [0x80u8, 0u8, 0u8, 0u8]);
                                                                                 let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                 let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                 fill_W_and_run_rounds(W, state),
-                                                                              ListNode.Cons(b36, tail) => match load(tail) {
-                                                                                ListNode.Nil =>
+                                                                              List.Cons(__cell37) => let (b36, tail) = load(__cell37); match tail {
+                                                                                List.Nil =>
                                                                                   let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 40u8]);
                                                                                   let W = set(W, 9, [b36, 0x80u8, 0u8, 0u8]);
                                                                                   let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                   let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                   fill_W_and_run_rounds(W, state),
-                                                                                ListNode.Cons(b37, tail) => match load(tail) {
-                                                                                  ListNode.Nil =>
+                                                                                List.Cons(__cell38) => let (b37, tail) = load(__cell38); match tail {
+                                                                                  List.Nil =>
                                                                                     let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 48u8]);
                                                                                     let W = set(W, 9, [b36, b37, 0x80u8, 0u8]);
                                                                                     let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                     let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                     fill_W_and_run_rounds(W, state),
-                                                                                  ListNode.Cons(b38, tail) => match load(tail) {
-                                                                                    ListNode.Nil =>
+                                                                                  List.Cons(__cell39) => let (b38, tail) = load(__cell39); match tail {
+                                                                                    List.Nil =>
                                                                                       let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 56u8]);
                                                                                       let W = set(W, 9, [b36, b37, b38, 0x80u8]);
                                                                                       let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                       let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                       fill_W_and_run_rounds(W, state),
-                                                                                    ListNode.Cons(b39, tail) =>
+                                                                                    List.Cons(__cell40) => let (b39, tail) = load(__cell40);
                                                                                       let W = set(W, 9, [b36, b37, b38, b39]);
-                                                                                      match load(tail) {
-                                                                                      ListNode.Nil =>
+                                                                                      match tail {
+                                                                                      List.Nil =>
                                                                                         let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 64u8]);
                                                                                         let W = set(W, 10, [0x80u8, 0u8, 0u8, 0u8]);
                                                                                         let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                         let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                         fill_W_and_run_rounds(W, state),
-                                                                                      ListNode.Cons(b40, tail) => match load(tail) {
-                                                                                        ListNode.Nil =>
+                                                                                      List.Cons(__cell41) => let (b40, tail) = load(__cell41); match tail {
+                                                                                        List.Nil =>
                                                                                           let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 72u8]);
                                                                                           let W = set(W, 10, [b40, 0x80u8, 0u8, 0u8]);
                                                                                           let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                           let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                           fill_W_and_run_rounds(W, state),
-                                                                                        ListNode.Cons(b41, tail) => match load(tail) {
-                                                                                          ListNode.Nil =>
+                                                                                        List.Cons(__cell42) => let (b41, tail) = load(__cell42); match tail {
+                                                                                          List.Nil =>
                                                                                             let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 80u8]);
                                                                                             let W = set(W, 10, [b40, b41, 0x80u8, 0u8]);
                                                                                             let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                             let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                             fill_W_and_run_rounds(W, state),
-                                                                                          ListNode.Cons(b42, tail) => match load(tail) {
-                                                                                            ListNode.Nil =>
+                                                                                          List.Cons(__cell43) => let (b42, tail) = load(__cell43); match tail {
+                                                                                            List.Nil =>
                                                                                               let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 88u8]);
                                                                                               let W = set(W, 10, [b40, b41, b42, 0x80u8]);
                                                                                               let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                               let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                               fill_W_and_run_rounds(W, state),
-                                                                                            ListNode.Cons(b43, tail) =>
+                                                                                            List.Cons(__cell44) => let (b43, tail) = load(__cell44);
                                                                                               let W = set(W, 10, [b40, b41, b42, b43]);
-                                                                                              match load(tail) {
-                                                                                              ListNode.Nil =>
+                                                                                              match tail {
+                                                                                              List.Nil =>
                                                                                                 let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 96u8]);
                                                                                                 let W = set(W, 11, [0x80u8, 0u8, 0u8, 0u8]);
                                                                                                 let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                                 let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                                 fill_W_and_run_rounds(W, state),
-                                                                                              ListNode.Cons(b44, tail) => match load(tail) {
-                                                                                                ListNode.Nil =>
+                                                                                              List.Cons(__cell45) => let (b44, tail) = load(__cell45); match tail {
+                                                                                                List.Nil =>
                                                                                                   let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 104u8]);
                                                                                                   let W = set(W, 11, [b44, 0x80u8, 0u8, 0u8]);
                                                                                                   let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                                   let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                                   fill_W_and_run_rounds(W, state),
-                                                                                                ListNode.Cons(b45, tail) => match load(tail) {
-                                                                                                  ListNode.Nil =>
+                                                                                                List.Cons(__cell46) => let (b45, tail) = load(__cell46); match tail {
+                                                                                                  List.Nil =>
                                                                                                     let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 112u8]);
                                                                                                     let W = set(W, 11, [b44, b45, 0x80u8, 0u8]);
                                                                                                     let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                                     let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                                     fill_W_and_run_rounds(W, state),
-                                                                                                  ListNode.Cons(b46, tail) => match load(tail) {
-                                                                                                    ListNode.Nil =>
+                                                                                                  List.Cons(__cell47) => let (b46, tail) = load(__cell47); match tail {
+                                                                                                    List.Nil =>
                                                                                                       let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 120u8]);
                                                                                                       let W = set(W, 11, [b44, b45, b46, 0x80u8]);
                                                                                                       let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                                       let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                                       fill_W_and_run_rounds(W, state),
-                                                                                                    ListNode.Cons(b47, tail) =>
+                                                                                                    List.Cons(__cell48) => let (b47, tail) = load(__cell48);
                                                                                                       let W = set(W, 11, [b44, b45, b46, b47]);
-                                                                                                      match load(tail) {
-                                                                                                      ListNode.Nil =>
+                                                                                                      match tail {
+                                                                                                      List.Nil =>
                                                                                                         let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 128u8]);
                                                                                                         let W = set(W, 12, [0x80u8, 0u8, 0u8, 0u8]);
                                                                                                         let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                                         let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                                         fill_W_and_run_rounds(W, state),
-                                                                                                      ListNode.Cons(b48, tail) => match load(tail) {
-                                                                                                        ListNode.Nil =>
+                                                                                                      List.Cons(__cell49) => let (b48, tail) = load(__cell49); match tail {
+                                                                                                        List.Nil =>
                                                                                                           let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 136u8]);
                                                                                                           let W = set(W, 12, [b48, 0x80u8, 0u8, 0u8]);
                                                                                                           let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                                           let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                                           fill_W_and_run_rounds(W, state),
-                                                                                                        ListNode.Cons(b49, tail) => match load(tail) {
-                                                                                                          ListNode.Nil =>
+                                                                                                        List.Cons(__cell50) => let (b49, tail) = load(__cell50); match tail {
+                                                                                                          List.Nil =>
                                                                                                             let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 144u8]);
                                                                                                             let W = set(W, 12, [b48, b49, 0x80u8, 0u8]);
                                                                                                             let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                                             let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                                             fill_W_and_run_rounds(W, state),
-                                                                                                          ListNode.Cons(b50, tail) => match load(tail) {
-                                                                                                            ListNode.Nil =>
+                                                                                                          List.Cons(__cell51) => let (b50, tail) = load(__cell51); match tail {
+                                                                                                            List.Nil =>
                                                                                                               let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 152u8]);
                                                                                                               let W = set(W, 12, [b48, b49, b50, 0x80u8]);
                                                                                                               let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                                               let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                                               fill_W_and_run_rounds(W, state),
-                                                                                                            ListNode.Cons(b51, tail) =>
+                                                                                                            List.Cons(__cell52) => let (b51, tail) = load(__cell52);
                                                                                                               let W = set(W, 12, [b48, b49, b50, b51]);
-                                                                                                              match load(tail) {
-                                                                                                              ListNode.Nil =>
+                                                                                                              match tail {
+                                                                                                              List.Nil =>
                                                                                                                 let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 160u8]);
                                                                                                                 let W = set(W, 13, [0x80u8, 0u8, 0u8, 0u8]);
                                                                                                                 let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                                                 let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                                                 fill_W_and_run_rounds(W, state),
-                                                                                                              ListNode.Cons(b52, tail) => match load(tail) {
-                                                                                                                ListNode.Nil =>
+                                                                                                              List.Cons(__cell53) => let (b52, tail) = load(__cell53); match tail {
+                                                                                                                List.Nil =>
                                                                                                                   let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 168u8]);
                                                                                                                   let W = set(W, 13, [b52, 0x80u8, 0u8, 0u8]);
                                                                                                                   let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                                                   let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                                                   fill_W_and_run_rounds(W, state),
-                                                                                                                ListNode.Cons(b53, tail) => match load(tail) {
-                                                                                                                  ListNode.Nil =>
+                                                                                                                List.Cons(__cell54) => let (b53, tail) = load(__cell54); match tail {
+                                                                                                                  List.Nil =>
                                                                                                                     let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 176u8]);
                                                                                                                     let W = set(W, 13, [b52, b53, 0x80u8, 0u8]);
                                                                                                                     let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                                                     let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                                                     fill_W_and_run_rounds(W, state),
-                                                                                                                  ListNode.Cons(b54, tail) => match load(tail) {
-                                                                                                                    ListNode.Nil =>
+                                                                                                                  List.Cons(__cell55) => let (b54, tail) = load(__cell55); match tail {
+                                                                                                                    List.Nil =>
                                                                                                                       let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 184u8]);
                                                                                                                       let W = set(W, 13, [b52, b53, b54, 0x80u8]);
                                                                                                                       let W = set(W, 14, [len_be[0], len_be[1], len_be[2], len_be[3]]);
                                                                                                                       let W = set(W, 15, [len_be[4], len_be[5], len_be[6], len_be[7]]);
                                                                                                                       fill_W_and_run_rounds(W, state),
-                                                                                                                    ListNode.Cons(b55, tail) =>
+                                                                                                                    List.Cons(__cell56) => let (b55, tail) = load(__cell56);
                                                                                                                       let W = set(W, 13, [b52, b53, b54, b55]);
-                                                                                                                      match load(tail) {
-                                                                                                                      ListNode.Nil =>
+                                                                                                                      match tail {
+                                                                                                                      List.Nil =>
                                                                                                                         let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 192u8]);
                                                                                                                         let W = set(W, 14, [0x80u8, 0u8, 0u8, 0u8]);
                                                                                                                         let state = fill_W_and_run_rounds(W, state);
                                                                                                                         fill_W_with_length_and_run_rounds(len_be, state),
-                                                                                                                      ListNode.Cons(b56, tail) => match load(tail) {
-                                                                                                                        ListNode.Nil =>
+                                                                                                                      List.Cons(__cell57) => let (b56, tail) = load(__cell57); match tail {
+                                                                                                                        List.Nil =>
                                                                                                                           let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 200u8]);
                                                                                                                           let W = set(W, 14, [b56, 0x80u8, 0u8, 0u8]);
                                                                                                                           let state = fill_W_and_run_rounds(W, state);
                                                                                                                           fill_W_with_length_and_run_rounds(len_be, state),
-                                                                                                                        ListNode.Cons(b57, tail) => match load(tail) {
-                                                                                                                          ListNode.Nil =>
+                                                                                                                        List.Cons(__cell58) => let (b57, tail) = load(__cell58); match tail {
+                                                                                                                          List.Nil =>
                                                                                                                             let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 208u8]);
                                                                                                                             let W = set(W, 14, [b56, b57, 0x80u8, 0u8]);
                                                                                                                             let state = fill_W_and_run_rounds(W, state);
                                                                                                                             fill_W_with_length_and_run_rounds(len_be, state),
-                                                                                                                          ListNode.Cons(b58, tail) => match load(tail) {
-                                                                                                                            ListNode.Nil =>
+                                                                                                                          List.Cons(__cell59) => let (b58, tail) = load(__cell59); match tail {
+                                                                                                                            List.Nil =>
                                                                                                                               let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 216u8]);
                                                                                                                               let W = set(W, 14, [b56, b57, b58, 0x80u8]);
                                                                                                                               let state = fill_W_and_run_rounds(W, state);
                                                                                                                               fill_W_with_length_and_run_rounds(len_be, state),
-                                                                                                                            ListNode.Cons(b59, tail) =>
+                                                                                                                            List.Cons(__cell60) => let (b59, tail) = load(__cell60);
                                                                                                                               let W = set(W, 14, [b56, b57, b58, b59]);
-                                                                                                                              match load(tail) {
-                                                                                                                              ListNode.Nil =>
+                                                                                                                              match tail {
+                                                                                                                              List.Nil =>
                                                                                                                                 let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 224u8]);
                                                                                                                                 let W = set(W, 15, [0x80u8, 0u8, 0u8, 0u8]);
                                                                                                                                 let state = fill_W_and_run_rounds(W, state);
                                                                                                                                 fill_W_with_length_and_run_rounds(len_be, state),
-                                                                                                                              ListNode.Cons(b60, tail) => match load(tail) {
-                                                                                                                                ListNode.Nil =>
+                                                                                                                              List.Cons(__cell61) => let (b60, tail) = load(__cell61); match tail {
+                                                                                                                                List.Nil =>
                                                                                                                                   let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 232u8]);
                                                                                                                                   let W = set(W, 15, [b60, 0x80u8, 0u8, 0u8]);
                                                                                                                                   let state = fill_W_and_run_rounds(W, state);
                                                                                                                                   fill_W_with_length_and_run_rounds(len_be, state),
-                                                                                                                                ListNode.Cons(b61, tail) => match load(tail) {
-                                                                                                                                  ListNode.Nil =>
+                                                                                                                                List.Cons(__cell62) => let (b61, tail) = load(__cell62); match tail {
+                                                                                                                                  List.Nil =>
                                                                                                                                     let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 240u8]);
                                                                                                                                     let W = set(W, 15, [b60, b61, 0x80u8, 0u8]);
                                                                                                                                     let state = fill_W_and_run_rounds(W, state);
                                                                                                                                     fill_W_with_length_and_run_rounds(len_be, state),
-                                                                                                                                  ListNode.Cons(b62, tail) => match load(tail) {
-                                                                                                                                    ListNode.Nil =>
+                                                                                                                                  List.Cons(__cell63) => let (b62, tail) = load(__cell63); match tail {
+                                                                                                                                    List.Nil =>
                                                                                                                                       let len_be = relaxed_u64_be_add_2_bytes(len_be, [1u8, 248u8]);
                                                                                                                                       let W = set(W, 15, [b60, b61, b62, 0x80u8]);
                                                                                                                                       let state = fill_W_and_run_rounds(W, state);
                                                                                                                                       fill_W_with_length_and_run_rounds(len_be, state),
-                                                                                                                                    ListNode.Cons(b63, tail) =>
+                                                                                                                                    List.Cons(__cell64) => let (b63, tail) = load(__cell64);
                                                                                                                                       let len_be = relaxed_u64_be_add_2_bytes(len_be, [2u8, 0u8]);
                                                                                                                                       let W = set(W, 15, [b60, b61, b62, b63]);
                                                                                                                                       let state = fill_W_and_run_rounds(W, state);
diff --git a/Ix/IxVM/Toplevel.lean b/Ix/IxVM/Toplevel.lean
index bfd5b070..773d7703 100644
--- a/Ix/IxVM/Toplevel.lean
+++ b/Ix/IxVM/Toplevel.lean
@@ -59,9 +59,9 @@ def entrypoints := ⟦
         let (idx, len) = io_get_info(0, [n_minus_1]);
         let bytes = #read_byte_stream(0, idx, len);
         let (const, rest) = get_constant(bytes);
-        assert_eq!(load(rest), ListNode.Nil,
+        assert_eq!(rest, List.Nil,
           "ixon deserialization left trailing bytes");
-        let bytes2 = put_constant(const, store(ListNode.Nil));
+        let bytes2 = put_constant(const, List.Nil);
         assert_eq!(bytes, bytes2,
           "ixon round-trip: re-serialized bytes differ from the input");
         ixon_serde_test(n_minus_1),
diff --git a/Ix/MultiStark.lean b/Ix/MultiStark.lean
index c9911442..ec9c1175 100644
--- a/Ix/MultiStark.lean
+++ b/Ix/MultiStark.lean
@@ -63,7 +63,7 @@ def entrypoints := ⟦
     let sbytes = #read_byte_stream(1, sidx, slen);
     assert_eq!(b3_to_digest(blake3(sbytes)), system_digest);
     let (sys, srest) = read_system(sbytes);
-    assert_eq!(load(srest), ListNode.Nil);
+    assert_eq!(srest, List.Nil);
     -- Public claims (`&[&[Val]]`) from IO channel 2: bind the bytes to the
     -- public Blake3 `claims_digest`, then deserialize. Binding them as a
     -- public input is what makes the lookup argument sound (a prover cannot
@@ -72,7 +72,7 @@ def entrypoints := ⟦
     let cbytes = #read_byte_stream(2, cidx, clen);
     assert_eq!(b3_to_digest(blake3(cbytes)), claims_digest);
     let (claims, crest) = read_claims(cbytes);
-    assert_eq!(load(crest), ListNode.Nil);
+    assert_eq!(crest, List.Nil);
     -- Structural + accumulator + PCS checks.
     assert_eq!(verify(proof), 1);
     -- Step 3 + 5: prover-faithful Fiat-Shamir replay and the out-of-domain
diff --git a/Ix/MultiStark/Deserialize.lean b/Ix/MultiStark/Deserialize.lean
index fb0cdf78..650a0788 100644
--- a/Ix/MultiStark/Deserialize.lean
+++ b/Ix/MultiStark/Deserialize.lean
@@ -132,9 +132,9 @@ def deserialize := ⟦
   -- ==========================================================================
 
   fn read_u8(stream: ByteStream) -> (U8, ByteStream) {
-    match load(stream) {
-      ListNode.Cons(byte, rest) => (byte, rest),
-      ListNode.Nil => (0u8, store(ListNode.Nil)),
+    match stream {
+      List.Cons(__cell1) => let (byte, rest) = load(__cell1); (byte, rest),
+      List.Nil => (0u8, List.Nil),
     }
   }
 
@@ -228,11 +228,11 @@ def deserialize := ⟦
   }
   fn read_u8_vec_n(i: G, n: G) -> (List‹U8›, G) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (x, j) = #read_u8_at(i);
         let (rest, j2) = read_u8_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
+        (List.Cons(store((x, rest))), j2),
     }
   }
 
@@ -242,11 +242,11 @@ def deserialize := ⟦
   }
   fn read_u64_vec_n(i: G, n: G) -> (List‹U64›, G) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (x, j) = #read_u64_at(i);
         let (rest, j2) = read_u64_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
+        (List.Cons(store((x, rest))), j2),
     }
   }
 
@@ -256,11 +256,11 @@ def deserialize := ⟦
   }
   fn read_ext_vec_n(i: G, n: G) -> (List‹Ext›, G) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (x, j) = read_ext_at(i);
         let (rest, j2) = read_ext_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
+        (List.Cons(store((x, rest))), j2),
     }
   }
 
@@ -270,11 +270,11 @@ def deserialize := ⟦
   }
   fn read_digest_vec_at_n(i: G, n: G) -> (List‹Digest›, G) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (x, j) = read_digest_at(i);
         let (rest, j2) = read_digest_vec_at_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
+        (List.Cons(store((x, rest))), j2),
     }
   }
 
@@ -285,11 +285,11 @@ def deserialize := ⟦
   }
   fn read_u64_vec_vec_n(i: G, n: G) -> (List‹List‹U64››, G) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (x, j) = read_u64_vec(i);
         let (rest, j2) = read_u64_vec_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
+        (List.Cons(store((x, rest))), j2),
     }
   }
 
@@ -300,11 +300,11 @@ def deserialize := ⟦
   }
   fn read_ext_vec_vec_n(i: G, n: G) -> (List‹List‹Ext››, G) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (x, j) = read_ext_vec(i);
         let (rest, j2) = read_ext_vec_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
+        (List.Cons(store((x, rest))), j2),
     }
   }
 
@@ -314,11 +314,11 @@ def deserialize := ⟦
   }
   fn read_opened_round_n(i: G, n: G) -> (OpenedRound, G) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (x, j) = read_ext_vec_vec(i);
         let (rest, j2) = read_opened_round_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
+        (List.Cons(store((x, rest))), j2),
     }
   }
 
@@ -335,11 +335,11 @@ def deserialize := ⟦
   }
   fn read_merkle_cap_vec_n(i: G, n: G) -> (List‹MerkleCap›, G) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (x, j) = read_merkle_cap_at(i);
         let (rest, j2) = read_merkle_cap_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
+        (List.Cons(store((x, rest))), j2),
     }
   }
 
@@ -361,11 +361,11 @@ def deserialize := ⟦
   }
   fn read_batch_opening_vec_n(i: G, n: G) -> (List‹BatchOpening›, G) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (x, j) = read_batch_opening(i);
         let (rest, j2) = read_batch_opening_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
+        (List.Cons(store((x, rest))), j2),
     }
   }
 
@@ -381,11 +381,11 @@ def deserialize := ⟦
   }
   fn read_commit_phase_step_vec_n(i: G, n: G) -> (List‹CommitPhaseProofStep›, G) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (x, j) = read_commit_phase_step(i);
         let (rest, j2) = read_commit_phase_step_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
+        (List.Cons(store((x, rest))), j2),
     }
   }
 
@@ -400,11 +400,11 @@ def deserialize := ⟦
   }
   fn read_query_proof_vec_n(i: G, n: G) -> (List‹QueryProof›, G) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (x, j) = read_query_proof(i);
         let (rest, j2) = read_query_proof_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
+        (List.Cons(store((x, rest))), j2),
     }
   }
 
@@ -426,11 +426,11 @@ def deserialize := ⟦
   }
   fn read_active_n(i: G, n: G) -> (List‹G›, G) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (b, j) = #read_u8_at(i);
         let (rest, j2) = read_active_n(j, n - 1);
-        (store(ListNode.Cons(to_field(b), rest)), j2),
+        (List.Cons(store((to_field(b), rest))), j2),
     }
   }
 
diff --git a/Ix/MultiStark/Keccak.lean b/Ix/MultiStark/Keccak.lean
index a2eb7e73..ee2edbcc 100644
--- a/Ix/MultiStark/Keccak.lean
+++ b/Ix/MultiStark/Keccak.lean
@@ -69,9 +69,9 @@ def keccak := ⟦
 
   -- Prepend the 8 bits of a byte decomposition (LSB first) onto `tail`.
   fn cons8(d: [G; 8], tail: List‹G›) -> List‹G› {
-    store(ListNode.Cons(d[0], store(ListNode.Cons(d[1], store(ListNode.Cons(d[2],
-    store(ListNode.Cons(d[3], store(ListNode.Cons(d[4], store(ListNode.Cons(d[5],
-    store(ListNode.Cons(d[6], store(ListNode.Cons(d[7], tail))))))))))))))))
+    List.Cons(store((d[0], List.Cons(store((d[1], List.Cons(store((d[2],
+    List.Cons(store((d[3], List.Cons(store((d[4], List.Cons(store((d[5],
+    List.Cons(store((d[6], List.Cons(store((d[7], tail))))))))))))))))))))))))
   }
 
   -- Lane → 64 bits, index z = 8*byte + bit, LSB first.
@@ -84,7 +84,7 @@ def keccak := ⟦
     cons8(u8_bit_decomposition(v[4]),
     cons8(u8_bit_decomposition(v[5]),
     cons8(u8_bit_decomposition(v[6]),
-    cons8(u8_bit_decomposition(v[7]), store(ListNode.Nil)))))))))
+    cons8(u8_bit_decomposition(v[7]), List.Nil))))))))
   }
 
   -- x mod 64 for x in [0, 127]: drop the 64-bit (bit 6).
@@ -100,14 +100,14 @@ def keccak := ⟦
   fn byte_from_bits(bs: List‹G›, off: G) -> U8 {
     -- One `list_drop` to the byte's first bit; the remaining 7 bits are the
     -- successive tails (a deref each), so no further drops are needed.
-    let &ListNode.Cons(b0, r0) = list_drop(bs, off);
-    let &ListNode.Cons(b1, r1) = r0;
-    let &ListNode.Cons(b2, r2) = r1;
-    let &ListNode.Cons(b3, r3) = r2;
-    let &ListNode.Cons(b4, r4) = r3;
-    let &ListNode.Cons(b5, r5) = r4;
-    let &ListNode.Cons(b6, r6) = r5;
-    let &ListNode.Cons(b7, _) = r6;
+    let List.Cons(__cell2) = list_drop(bs, off); let (b0, r0) = load(__cell2);
+    let List.Cons(__cell3) = r0; let (b1, r1) = load(__cell3);
+    let List.Cons(__cell4) = r1; let (b2, r2) = load(__cell4);
+    let List.Cons(__cell5) = r2; let (b3, r3) = load(__cell5);
+    let List.Cons(__cell6) = r3; let (b4, r4) = load(__cell6);
+    let List.Cons(__cell7) = r4; let (b5, r5) = load(__cell7);
+    let List.Cons(__cell8) = r5; let (b6, r6) = load(__cell8);
+    let List.Cons(__cell9) = r6; let (b7, _) = load(__cell9);
     u8_from_field_unsafe(
       b0 + 2 * b1 + 4 * b2 + 8 * b3 + 16 * b4 + 32 * b5 + 64 * b6 + 128 * b7)
   }
@@ -121,11 +121,11 @@ def keccak := ⟦
   -- bit (p - n) mod 64 = mod64(p + 64 - n).
   fn build_rot(bs: List‹G›, n: G, p: G) -> List‹G› {
     match 64 - p {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ =>
         let src = mod64(p + 64 - n);
-        let &ListNode.Cons(head, _) = list_drop(bs, src);
-        store(ListNode.Cons(head, build_rot(bs, n, p + 1))),
+        let List.Cons(__cell10) = list_drop(bs, src); let (head, _) = load(__cell10);
+        List.Cons(store((head, build_rot(bs, n, p + 1)))),
     }
   }
 
@@ -271,10 +271,10 @@ def keccak := ⟦
   -- `eq_zero` (an op) instead of a match so it stays tail-position-compilable.
   fn build_pad(i: G, first: G) -> ByteStream {
     match 136 - i {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ =>
-        store(ListNode.Cons(u8_from_field_unsafe(first + 128 * eq_zero(135 - i)),
-                            build_pad(i + 1, 0))),
+        List.Cons(store((u8_from_field_unsafe(first + 128 * eq_zero(135 - i)),
+                            build_pad(i + 1, 0)))),
     }
   }
 
@@ -286,26 +286,26 @@ def keccak := ⟦
   -- block keccak appends when the message length is a multiple of 136.
   fn read_block(stream: ByteStream, i: G) -> (ByteStream, ByteStream, G) {
     match 136 - i {
-      0 => (store(ListNode.Nil), stream, 1),
-      _ => match load(stream) {
-        ListNode.Cons(b, rest) =>
+      0 => (List.Nil, stream, 1),
+      _ => match stream {
+        List.Cons(__cell1) => let (b, rest) = load(__cell1);
           let (blk, r, f) = read_block(rest, i + 1);
-          (store(ListNode.Cons(b, blk)), r, f),
-        ListNode.Nil => (build_pad(i, 1), store(ListNode.Nil), 0),
+          (List.Cons(store((b, blk))), r, f),
+        List.Nil => (build_pad(i, 1), List.Nil, 0),
       },
     }
   }
 
   fn rate_lane(rate: ByteStream, b: G) -> Lane {
     -- One `list_drop` to the lane's first byte; the next 7 are successive tails.
-    let &ListNode.Cons(r0, t0) = list_drop(rate, b);
-    let &ListNode.Cons(r1, t1) = t0;
-    let &ListNode.Cons(r2, t2) = t1;
-    let &ListNode.Cons(r3, t3) = t2;
-    let &ListNode.Cons(r4, t4) = t3;
-    let &ListNode.Cons(r5, t5) = t4;
-    let &ListNode.Cons(r6, t6) = t5;
-    let &ListNode.Cons(r7, _) = t6;
+    let List.Cons(__cell11) = list_drop(rate, b); let (r0, t0) = load(__cell11);
+    let List.Cons(__cell12) = t0; let (r1, t1) = load(__cell12);
+    let List.Cons(__cell13) = t1; let (r2, t2) = load(__cell13);
+    let List.Cons(__cell14) = t2; let (r3, t3) = load(__cell14);
+    let List.Cons(__cell15) = t3; let (r4, t4) = load(__cell15);
+    let List.Cons(__cell16) = t4; let (r5, t5) = load(__cell16);
+    let List.Cons(__cell17) = t5; let (r6, t6) = load(__cell17);
+    let List.Cons(__cell18) = t6; let (r7, _) = load(__cell18);
     store([r0, r1, r2, r3, r4, r5, r6, r7])
   }
 
diff --git a/Ix/MultiStark/Pcs.lean b/Ix/MultiStark/Pcs.lean
index 6fb9bd00..6a3579e2 100644
--- a/Ix/MultiStark/Pcs.lean
+++ b/Ix/MultiStark/Pcs.lean
@@ -43,21 +43,21 @@ def pcs := ⟦
 
   -- 8 LE bytes of a `U64` lane (`SerializingHasher`: a `Val` is 8 LE bytes).
   fn b3_u64_onto(v: U64, tail: ByteStream) -> ByteStream {
-    store(ListNode.Cons(v[0], store(ListNode.Cons(v[1], store(ListNode.Cons(v[2],
-    store(ListNode.Cons(v[3], store(ListNode.Cons(v[4], store(ListNode.Cons(v[5],
-    store(ListNode.Cons(v[6], store(ListNode.Cons(v[7], tail))))))))))))))))
+    List.Cons(store((v[0], List.Cons(store((v[1], List.Cons(store((v[2],
+    List.Cons(store((v[3], List.Cons(store((v[4], List.Cons(store((v[5],
+    List.Cons(store((v[6], List.Cons(store((v[7], tail))))))))))))))))))))))))
   }
   -- All lanes of a row, in order.
   fn b3_row_onto(row: List‹U64›, tail: ByteStream) -> ByteStream {
-    match load(row) {
-      ListNode.Nil => tail,
-      ListNode.Cons(v, rest) => b3_u64_onto(v, b3_row_onto(rest, tail)),
+    match row {
+      List.Nil => tail,
+      List.Cons(__cell1) => let (v, rest) = load(__cell1); b3_u64_onto(v, b3_row_onto(rest, tail)),
     }
   }
   -- A 4-byte blake3 output word.
   fn b3_w4_onto(w: [U8; 4], tail: ByteStream) -> ByteStream {
-    store(ListNode.Cons(w[0], store(ListNode.Cons(w[1], store(ListNode.Cons(w[2],
-    store(ListNode.Cons(w[3], tail))))))))
+    List.Cons(store((w[0], List.Cons(store((w[1], List.Cons(store((w[2],
+    List.Cons(store((w[3], tail))))))))))))
   }
   -- The 32 bytes of a blake3 digest (`[[U8;4];8]`, word order = output order).
   fn b3_flatten_onto(h: [[U8; 4]; 8], tail: ByteStream) -> ByteStream {
@@ -86,23 +86,23 @@ def pcs := ⟦
   -- lanes, its real byte length (8·k, so 64 for a full block), and the rest.
   fn b3_lane_block(lanes: List‹U64›) -> ([U64; 8], G, List‹U64›) {
     let z = [0u8; 8];
-    match load(lanes) {
-      ListNode.Nil => ([z; 8], 0, lanes),
-      ListNode.Cons(v0, r0) => match load(r0) {
-        ListNode.Nil => ([v0, z, z, z, z, z, z, z], 8, r0),
-        ListNode.Cons(v1, r1) => match load(r1) {
-          ListNode.Nil => ([v0, v1, z, z, z, z, z, z], 16, r1),
-          ListNode.Cons(v2, r2) => match load(r2) {
-            ListNode.Nil => ([v0, v1, v2, z, z, z, z, z], 24, r2),
-            ListNode.Cons(v3, r3) => match load(r3) {
-              ListNode.Nil => ([v0, v1, v2, v3, z, z, z, z], 32, r3),
-              ListNode.Cons(v4, r4) => match load(r4) {
-                ListNode.Nil => ([v0, v1, v2, v3, v4, z, z, z], 40, r4),
-                ListNode.Cons(v5, r5) => match load(r5) {
-                  ListNode.Nil => ([v0, v1, v2, v3, v4, v5, z, z], 48, r5),
-                  ListNode.Cons(v6, r6) => match load(r6) {
-                    ListNode.Nil => ([v0, v1, v2, v3, v4, v5, v6, z], 56, r6),
-                    ListNode.Cons(v7, r7) =>
+    match lanes {
+      List.Nil => ([z; 8], 0, lanes),
+      List.Cons(__cell2) => let (v0, r0) = load(__cell2); match r0 {
+        List.Nil => ([v0, z, z, z, z, z, z, z], 8, r0),
+        List.Cons(__cell3) => let (v1, r1) = load(__cell3); match r1 {
+          List.Nil => ([v0, v1, z, z, z, z, z, z], 16, r1),
+          List.Cons(__cell4) => let (v2, r2) = load(__cell4); match r2 {
+            List.Nil => ([v0, v1, v2, z, z, z, z, z], 24, r2),
+            List.Cons(__cell5) => let (v3, r3) = load(__cell5); match r3 {
+              List.Nil => ([v0, v1, v2, v3, z, z, z, z], 32, r3),
+              List.Cons(__cell6) => let (v4, r4) = load(__cell6); match r4 {
+                List.Nil => ([v0, v1, v2, v3, v4, z, z, z], 40, r4),
+                List.Cons(__cell7) => let (v5, r5) = load(__cell7); match r5 {
+                  List.Nil => ([v0, v1, v2, v3, v4, v5, z, z], 48, r5),
+                  List.Cons(__cell8) => let (v6, r6) = load(__cell8); match r6 {
+                    List.Nil => ([v0, v1, v2, v3, v4, v5, v6, z], 56, r6),
+                    List.Cons(__cell9) => let (v7, r7) = load(__cell9);
                       ([v0, v1, v2, v3, v4, v5, v6, v7], 64, r7),
                   },
                 },
@@ -118,15 +118,15 @@ def pcs := ⟦
   -- current chunk (0..15); `cv` is the chaining value (IV at each chunk start);
   -- chunk digests are pushed onto `layer` in order, exactly like the byte
   -- driver, and folded by `blake3_compress_layer` at the end.
-  fn b3_lane_chunks(lanes: List‹U64›, block_no: G, chunk_count: &U64, cv: &[[U8; 4]; 8], layer: &Layer) -> &Layer {
-    match load(lanes) {
+  fn b3_lane_chunks(lanes: List‹U64›, block_no: G, chunk_count: &U64, cv: &[[U8; 4]; 8], layer: Layer) -> Layer {
+    match lanes {
       -- Exhausted with no block to compress: only reachable for an empty
       -- input (every other path detects exhaustion after compressing).
       -- Mirror of `blake3_finish`'s (0, 0) arm.
-      ListNode.Nil =>
+      List.Nil =>
         match load(chunk_count) {
           [0, 0, 0, 0, 0, 0, 0, 0] =>
-            store(Layer.Push(layer, blake3_compress(load(cv), [[0u8; 4]; 16], load(chunk_count), 0, 11))),
+            Layer.Push(store((layer, blake3_compress(load(cv), [[0u8; 4]; 16], load(chunk_count), 0, 11)))),
           _ => layer,
         },
       _ =>
@@ -140,7 +140,7 @@ def pcs := ⟦
           [v[5][0], v[5][1], v[5][2], v[5][3]], [v[5][4], v[5][5], v[5][6], v[5][7]],
           [v[6][0], v[6][1], v[6][2], v[6][3]], [v[6][4], v[6][5], v[6][6], v[6][7]],
           [v[7][0], v[7][1], v[7][2], v[7][3]], [v[7][4], v[7][5], v[7][6], v[7][7]]];
-        let empty = match load(rest) { ListNode.Nil => 1, _ => 0, };
+        let empty = match rest { List.Nil => 1, _ => 0, };
         let at15 = eq_zero(block_no - 15);
         -- CHUNK_START on the chunk's first block; CHUNK_END iff this is the
         -- chunk's 16th block OR the input ends here; ROOT only for the last
@@ -152,10 +152,10 @@ def pcs := ⟦
         let flags = start_flag + 2 * end_flag + 8 * root_flag;
         let digest = blake3_compress(load(cv), block, load(chunk_count), nbytes, flags);
         match (empty, at15) {
-          (1, _) => store(Layer.Push(layer, digest)),
+          (1, _) => Layer.Push(store((layer, digest))),
           (_, 1) =>
             let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
-            b3_lane_chunks(rest, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), store(Layer.Push(layer, digest))),
+            b3_lane_chunks(rest, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), Layer.Push(store((layer, digest)))),
           (_, _) => b3_lane_chunks(rest, block_no + 1, chunk_count, store(digest), layer),
         },
     }
@@ -180,11 +180,11 @@ def pcs := ⟦
       _ =>
         let [b] = io_read(ch, i, 1);
         b3_io_tail_acc(ch, i + 1, n - 1,
-          store(ListNode.Cons(u8_from_field_unsafe(b), acc))),
+          List.Cons(store((u8_from_field_unsafe(b), acc)))),
     }
   }
 
-  fn b3_io_chunks(ch: G, i: G, remaining: G, block_no: G, chunk_count: &U64, cv: &[[U8; 4]; 8], layer: &Layer) -> &Layer {
+  fn b3_io_chunks(ch: G, i: G, remaining: G, block_no: G, chunk_count: &U64, cv: &[[U8; 4]; 8], layer: Layer) -> Layer {
     match u32_less_than(remaining, 64) {
       0 =>
         -- A full 64-byte block is available.
@@ -218,10 +218,10 @@ def pcs := ⟦
         let flags = start_flag + 2 * end_flag + 8 * root_flag;
         let digest = blake3_compress(load(cv), block, load(chunk_count), 64, flags);
         match (is_last, at15) {
-          (1, _) => store(Layer.Push(layer, digest)),
+          (1, _) => Layer.Push(store((layer, digest))),
           (_, 1) =>
             let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
-            b3_io_chunks(ch, i + 64, remaining - 64, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), store(Layer.Push(layer, digest))),
+            b3_io_chunks(ch, i + 64, remaining - 64, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), Layer.Push(store((layer, digest)))),
           (_, _) => b3_io_chunks(ch, i + 64, remaining - 64, block_no + 1, chunk_count, store(digest), layer),
         },
       _ =>
@@ -232,15 +232,15 @@ def pcs := ⟦
             -- (0, 0) arm (any other path compresses before exhausting).
             match load(chunk_count) {
               [0, 0, 0, 0, 0, 0, 0, 0] =>
-                store(Layer.Push(layer, blake3_compress(load(cv), [[0u8; 4]; 16], load(chunk_count), 0, 11))),
+                Layer.Push(store((layer, blake3_compress(load(cv), [[0u8; 4]; 16], load(chunk_count), 0, 11)))),
               _ => layer,
             },
           _ =>
             let block = bytes_to_block(pad_block(
-              b3_io_tail_acc(ch, i, remaining, store(ListNode.Nil)), 64 - remaining));
+              b3_io_tail_acc(ch, i, remaining, List.Nil), 64 - remaining));
             let start_flag = eq_zero(block_no);
             let flags = start_flag + 2 + 8 * u64_is_zero(load(chunk_count));
-            store(Layer.Push(layer, blake3_compress(load(cv), block, load(chunk_count), remaining, flags))),
+            Layer.Push(store((layer, blake3_compress(load(cv), block, load(chunk_count), remaining, flags)))),
         },
     }
   }
@@ -249,14 +249,14 @@ def pcs := ⟦
   -- output to `blake3` over those bytes — pinned by `io_hash_test`).
   fn b3_io(ch: G, idx: G, len: G) -> [[U8; 4]; 8] {
     let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
-    blake3_compress_layer(load(b3_io_chunks(ch, idx, len, 0, store([0u8; 8]), store(IV), store(Layer.Nil))))
+    blake3_compress_layer((b3_io_chunks(ch, idx, len, 0, store([0u8; 8]), store(IV), Layer.Nil)))
   }
 
   -- blake3 of a lane list (identical output to `blake3` over the lanes' LE
   -- bytes — pinned by the `lane_hash_test` differential self-test).
   fn b3_lanes(lanes: List‹U64›) -> [[U8; 4]; 8] {
     let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
-    blake3_compress_layer(load(b3_lane_chunks(lanes, 0, store([0u8; 8]), store(IV), store(Layer.Nil))))
+    blake3_compress_layer((b3_lane_chunks(lanes, 0, store([0u8; 8]), store(IV), Layer.Nil)))
   }
 
   -- The MMCS leaf hash of a row (`SerializingHasher<Blake3>`).
@@ -320,9 +320,9 @@ def pcs := ⟦
 
   -- 1 iff some matrix has log-height `target`.
   fn has_height(lhs: List‹G›, target: G) -> G {
-    match load(lhs) {
-      ListNode.Nil => 0,
-      ListNode.Cons(h, rest) =>
+    match lhs {
+      List.Nil => 0,
+      List.Cons(__cell10) => let (h, rest) = load(__cell10);
         match eq_zero(h - target) {
           1 => 1,
           _ => has_height(rest, target),
@@ -334,10 +334,10 @@ def pcs := ⟦
   -- (in matrix order — the stable height-sort preserves it), for the joint leaf
   -- hash `hash_iter_slices`.
   fn concat_at(rows: List‹List‹U64››, lhs: List‹G›, target: G) -> List‹U64› {
-    match load(rows) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(r, rrest) =>
-        let &ListNode.Cons(lh, lrest) = lhs;
+    match rows {
+      List.Nil => List.Nil,
+      List.Cons(__cell11) => let (r, rrest) = load(__cell11);
+        let List.Cons(__cell33) = lhs; let (lh, lrest) = load(__cell33);
         concat_at_step(eq_zero(lh - target), r, rrest, lrest, target),
     }
   }
@@ -354,9 +354,9 @@ def pcs := ⟦
   -- internal Goldilocks repr — e.g. field zero ships as `p`. `gl_reduce` maps
   -- them to `< p` before hashing (idempotent on already-canonical lanes).
   fn canon_lanes(l: List‹U64›) -> List‹U64› {
-    match load(l) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(x, rest) => store(ListNode.Cons(@gl_to_bytes(@gl_val(x)), canon_lanes(rest))),
+    match l {
+      List.Nil => List.Nil,
+      List.Cons(__cell12) => let (x, rest) = load(__cell12); List.Cons(store((@gl_to_bytes(@gl_val(x)), canon_lanes(rest)))),
     }
   }
   -- ==========================================================================
@@ -371,15 +371,15 @@ def pcs := ⟦
   -- contributes no bytes, and dropping it lets exhaustion be detected by
   -- plain Nil checks in the block walker).
   fn select_rows(rows: List‹List‹U64››, lhs: List‹G›, target: G) -> List‹List‹U64›› {
-    match load(rows) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(r, rrest) =>
-        let &ListNode.Cons(lh, lrest) = lhs;
+    match rows {
+      List.Nil => List.Nil,
+      List.Cons(__cell13) => let (r, rrest) = load(__cell13);
+        let List.Cons(__cell34) = lhs; let (lh, lrest) = load(__cell34);
         match eq_zero(lh - target) {
           0 => select_rows(rrest, lrest, target),
-          _ => match load(r) {
-            ListNode.Nil => select_rows(rrest, lrest, target),
-            _ => store(ListNode.Cons(r, select_rows(rrest, lrest, target))),
+          _ => match r {
+            List.Nil => select_rows(rrest, lrest, target),
+            _ => List.Cons(store((r, select_rows(rrest, lrest, target)))),
           },
         },
     }
@@ -389,11 +389,11 @@ def pcs := ⟦
   -- current row and the remaining rows are exhausted (selected rows are
   -- non-empty, so advancing to the next row always yields a lane).
   fn rows_pop(cur: List‹U64›, rows: List‹List‹U64››) -> (U64, List‹U64›, List‹List‹U64››, G) {
-    match load(cur) {
-      ListNode.Cons(x, rest) => (@gl_to_bytes(@gl_val(x)), rest, rows, 1),
-      ListNode.Nil => match load(rows) {
-        ListNode.Nil => ([0u8; 8], cur, rows, 0),
-        ListNode.Cons(r, rrest) => rows_pop(r, rrest),
+    match cur {
+      List.Cons(__cell14) => let (x, rest) = load(__cell14); (@gl_to_bytes(@gl_val(x)), rest, rows, 1),
+      List.Nil => match rows {
+        List.Nil => ([0u8; 8], cur, rows, 0),
+        List.Cons(__cell15) => let (r, rrest) = load(__cell15); rows_pop(r, rrest),
       },
     }
   }
@@ -401,7 +401,7 @@ def pcs := ⟦
   -- Block-granular chunk walk over rows-of-lanes; mirrors `b3_lane_chunks`
   -- (same flag schedule, same `Layer` fold), gathering each 64-byte block
   -- with eight cross-row pops.
-  fn b3_rows_chunks(cur: List‹U64›, rows: List‹List‹U64››, block_no: G, chunk_count: &U64, cv: &[[U8; 4]; 8], layer: &Layer) -> &Layer {
+  fn b3_rows_chunks(cur: List‹U64›, rows: List‹List‹U64››, block_no: G, chunk_count: &U64, cv: &[[U8; 4]; 8], layer: Layer) -> Layer {
     let (l0, c1, r1, g0) = rows_pop(cur, rows);
     match g0 {
       -- Exhausted with no block to compress: only reachable for an empty
@@ -409,7 +409,7 @@ def pcs := ⟦
       0 =>
         match load(chunk_count) {
           [0, 0, 0, 0, 0, 0, 0, 0] =>
-            store(Layer.Push(layer, blake3_compress(load(cv), [[0u8; 4]; 16], load(chunk_count), 0, 11))),
+            Layer.Push(store((layer, blake3_compress(load(cv), [[0u8; 4]; 16], load(chunk_count), 0, 11)))),
           _ => layer,
         },
       _ =>
@@ -430,8 +430,8 @@ def pcs := ⟦
           [l5[0], l5[1], l5[2], l5[3]], [l5[4], l5[5], l5[6], l5[7]],
           [l6[0], l6[1], l6[2], l6[3]], [l6[4], l6[5], l6[6], l6[7]],
           [l7[0], l7[1], l7[2], l7[3]], [l7[4], l7[5], l7[6], l7[7]]];
-        let empty = match load(c8) {
-          ListNode.Nil => match load(r8) { ListNode.Nil => 1, _ => 0, },
+        let empty = match c8 {
+          List.Nil => match r8 { List.Nil => 1, _ => 0, },
           _ => 0,
         };
         let at15 = eq_zero(block_no - 15);
@@ -441,10 +441,10 @@ def pcs := ⟦
         let flags = start_flag + 2 * end_flag + 8 * root_flag;
         let digest = blake3_compress(load(cv), block, load(chunk_count), nbytes, flags);
         match (empty, at15) {
-          (1, _) => store(Layer.Push(layer, digest)),
+          (1, _) => Layer.Push(store((layer, digest))),
           (_, 1) =>
             let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
-            b3_rows_chunks(c8, r8, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), store(Layer.Push(layer, digest))),
+            b3_rows_chunks(c8, r8, 0, store(relaxed_u64_succ(load(chunk_count))), store(IV), Layer.Push(store((layer, digest)))),
           (_, _) => b3_rows_chunks(c8, r8, block_no + 1, chunk_count, store(digest), layer),
         },
     }
@@ -452,7 +452,7 @@ def pcs := ⟦
 
   fn b3_rows(rows: List‹List‹U64››) -> [[U8; 4]; 8] {
     let IV = [[103u8, 230u8, 9u8, 106u8], [133u8, 174u8, 103u8, 187u8], [114u8, 243u8, 110u8, 60u8], [58u8, 245u8, 79u8, 165u8], [127u8, 82u8, 14u8, 81u8], [140u8, 104u8, 5u8, 155u8], [171u8, 217u8, 131u8, 31u8], [25u8, 205u8, 224u8, 91u8]];
-    blake3_compress_layer(load(b3_rows_chunks(store(ListNode.Nil), rows, 0, store([0u8; 8]), store(IV), store(Layer.Nil))))
+    blake3_compress_layer((b3_rows_chunks(List.Nil, rows, 0, store([0u8; 8]), store(IV), Layer.Nil)))
   }
 
   -- The joint Blake3 leaf hash of all matrices at log-height `target`.
@@ -471,9 +471,9 @@ def pcs := ⟦
 
   -- Recompose remaining path bits (LSB first) into the cap index.
   fn bits_to_num(bits: List‹G›) -> G {
-    match load(bits) {
-      ListNode.Nil => 0,
-      ListNode.Cons(b, rest) => b + 2 * bits_to_num(rest),
+    match bits {
+      List.Nil => 0,
+      List.Cons(__cell16) => let (b, rest) = load(__cell16); b + 2 * bits_to_num(rest),
     }
   }
 
@@ -482,10 +482,10 @@ def pcs := ⟦
   -- root and the leftover cap index.
   fn mmcs_fold(d: Digest, rows: List‹List‹U64››, lhs: List‹G›,
       proof: List‹Digest›, ibits: List‹G›, lh: G) -> (Digest, G) {
-    match load(proof) {
-      ListNode.Nil => (d, bits_to_num(ibits)),
-      ListNode.Cons(s, prest) =>
-        let &ListNode.Cons(bit, brest) = ibits;
+    match proof {
+      List.Nil => (d, bits_to_num(ibits)),
+      List.Cons(__cell17) => let (s, prest) = load(__cell17);
+        let List.Cons(__cell35) = ibits; let (bit, brest) = load(__cell35);
         let d1 = compress_ordered(bit, d, s);
         let d2 = inject_maybe(rows, lhs, lh, d1);
         mmcs_fold(d2, rows, lhs, prest, brest, lh - 1),
@@ -521,18 +521,18 @@ def pcs := ⟦
 
   -- Reverse a `G` (bit) list onto `acc`.
   fn glist_rev(l: List‹G›, acc: List‹G›) -> List‹G› {
-    match load(l) {
-      ListNode.Nil => acc,
-      ListNode.Cons(b, rest) => glist_rev(rest, store(ListNode.Cons(b, acc))),
+    match l {
+      List.Nil => acc,
+      List.Cons(__cell18) => let (b, rest) = load(__cell18); glist_rev(rest, List.Cons(store((b, acc)))),
     }
   }
 
   -- base^(Σ bits_i · 2^i), bits LSB-first (square-and-multiply over the bits).
   -- `base` is a native Goldilocks element; `bits` is a native bit list.
   fn exp_by_bits(base: Goldilocks, bits: List‹G›) -> Goldilocks {
-    match load(bits) {
-      ListNode.Nil => 1,
-      ListNode.Cons(b, rest) =>
+    match bits {
+      List.Nil => 1,
+      List.Cons(__cell19) => let (b, rest) = load(__cell19);
         let half = exp_by_bits(base * base, rest);
         match b {
           0 => half,
@@ -545,7 +545,7 @@ def pcs := ⟦
   -- first (so `reverse_bits_len` = reversing the list).
   fn fri_fold2(index_bits: List‹G›, log_height: G, beta: Ext, e0: Ext, e1: Ext) -> Ext {
     let g = two_adic_gen(log_height + 1);
-    let s = exp_by_bits(g, glist_rev(index_bits, store(ListNode.Nil)));
+    let s = exp_by_bits(g, glist_rev(index_bits, List.Nil));
     let two_s = s + s;
     let t1 = @eg_div(@eg_add(e0, e1), [2, 0]);
     let t2 = @eg_mul(beta, @eg_div(@eg_sub(e0, e1), [two_s, 0]));
@@ -568,25 +568,25 @@ def pcs := ⟦
   -- The base-field query domain point x. `index_bits` = low-`log_height` index
   -- bits, LSB first (so reverse_bits_len = reversing the list).
   fn ro_x(index_bits: List‹G›, log_height: G) -> Goldilocks {
-    7 * exp_by_bits(two_adic_gen(log_height), glist_rev(index_bits, store(ListNode.Nil)))
+    7 * exp_by_bits(two_adic_gen(log_height), glist_rev(index_bits, List.Nil))
   }
 
   -- Raw wire rows (`U64` lanes, possibly non-canonical) to native Goldilocks
   -- values for the reduced-opening arithmetic (`limb_to_field` reduces mod p).
   fn lanes_to_gl(l: List‹U64›) -> List‹Goldilocks› {
-    match load(l) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(x, rest) => store(ListNode.Cons(@limb_to_field(x), lanes_to_gl(rest))),
+    match l {
+      List.Nil => List.Nil,
+      List.Cons(__cell20) => let (x, rest) = load(__cell20); List.Cons(store((@limb_to_field(x), lanes_to_gl(rest)))),
     }
   }
 
   -- Accumulate one matrix-point's column contributions. `q = 1/(z − x)`.
   fn ro_fold(p_x: List‹Goldilocks›, p_z: List‹Ext›, q: Ext, alpha: Ext, ro: Ext, ap: Ext)
       -> (Ext, Ext) {
-    match load(p_x) {
-      ListNode.Nil => (ro, ap),
-      ListNode.Cons(px, pxr) =>
-        let &ListNode.Cons(pz, pzr) = p_z;
+    match p_x {
+      List.Nil => (ro, ap),
+      List.Cons(__cell21) => let (px, pxr) = load(__cell21);
+        let List.Cons(__cell36) = p_z; let (pz, pzr) = load(__cell36);
         let term = @eg_mul(@eg_mul(ap, @eg_sub(pz, [px, 0])), q);
         ro_fold(pxr, pzr, q, alpha, @eg_add(ro, term), @eg_mul(ap, alpha)),
     }
@@ -617,21 +617,21 @@ def pcs := ⟦
   -- billions of memory records.
   -- One ext element = its two base coordinates, each 8 LE bytes.
   fn ext_row_onto(row: List‹Ext›, tail: ByteStream) -> ByteStream {
-    match load(row) {
-      ListNode.Nil => tail,
-      ListNode.Cons(e, rest) => b8_onto(@gl_to_bytes(e[0]), b8_onto(@gl_to_bytes(e[1]), ext_row_onto(rest, tail))),
+    match row {
+      List.Nil => tail,
+      List.Cons(__cell22) => let (e, rest) = load(__cell22); b8_onto(@gl_to_bytes(e[0]), b8_onto(@gl_to_bytes(e[1]), ext_row_onto(rest, tail))),
     }
   }
   fn points_onto(pts: List‹List‹Ext››, tail: ByteStream) -> ByteStream {
-    match load(pts) {
-      ListNode.Nil => tail,
-      ListNode.Cons(row, rest) => ext_row_onto(row, points_onto(rest, tail)),
+    match pts {
+      List.Nil => tail,
+      List.Cons(__cell23) => let (row, rest) = load(__cell23); ext_row_onto(row, points_onto(rest, tail)),
     }
   }
   fn round_onto(round: OpenedRound, tail: ByteStream) -> ByteStream {
-    match load(round) {
-      ListNode.Nil => tail,
-      ListNode.Cons(mat, rest) => points_onto(mat, round_onto(rest, tail)),
+    match round {
+      List.Nil => tail,
+      List.Cons(__cell24) => let (mat, rest) = load(__cell24); points_onto(mat, round_onto(rest, tail)),
     }
   }
   fn prep_onto(prep_opt: PreprocessedOpt, tail: ByteStream) -> ByteStream {
@@ -642,9 +642,9 @@ def pcs := ⟦
   }
   -- Observe one Val (= 1) per FRI round, the variable-arity schedule.
   fn obs_log_arities(input: ByteStream, comms: List‹MerkleCap›) -> ByteStream {
-    match load(comms) {
-      ListNode.Nil => input,
-      ListNode.Cons(_c, rest) =>
+    match comms {
+      List.Nil => input,
+      List.Cons(__cell25) => let (_c, rest) = load(__cell25);
         obs_log_arities(snoc_b8(input, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), rest),
     }
   }
@@ -657,9 +657,9 @@ def pcs := ⟦
   -- observe, no sample.
   fn pcs_check_witness(input: ByteStream, witness: U64, bits: G) -> (ByteStream, ByteStream) {
     match bits {
-      0 => (input, store(ListNode.Nil)),
+      0 => (input, List.Nil),
       _ =>
-        let (pbits, i1, o1) = ch_sample_bits(snoc_b8(input, witness), store(ListNode.Nil), bits);
+        let (pbits, i1, o1) = ch_sample_bits(snoc_b8(input, witness), List.Nil, bits);
         assert_eq!(bits_to_num(pbits), 0);
         (i1, o1),
     }
@@ -668,14 +668,14 @@ def pcs := ⟦
   -- sample the folding challenge β (continuing the challenger past the PoW).
   fn pcs_betas(input: ByteStream, comms: List‹MerkleCap›, witnesses: List‹U64›, bits: G)
       -> (List‹Ext›, ByteStream) {
-    match load(comms) {
-      ListNode.Nil => (store(ListNode.Nil), input),
-      ListNode.Cons(c, rest) =>
-        let &ListNode.Cons(w, wrest) = witnesses;
+    match comms {
+      List.Nil => (List.Nil, input),
+      List.Cons(__cell26) => let (c, rest) = load(__cell26);
+        let List.Cons(__cell37) = witnesses; let (w, wrest) = load(__cell37);
         let (i1, o1) = pcs_check_witness(snoc_cap(input, c), w, bits);
         let (b0, b1, i2, _o) = ch_sample_ext(i1, o1);
         let (bs, i3) = pcs_betas(i2, rest, wrest, bits);
-        (store(ListNode.Cons([@gl_val(b0), @gl_val(b1)], bs)), i3),
+        (List.Cons(store(([@gl_val(b0), @gl_val(b1)], bs))), i3),
     }
   }
 
@@ -694,12 +694,12 @@ def pcs := ⟦
   -- from `log_global_max`. Each starts (alpha_pow = 1, reduced_opening = 0).
   fn build_buckets(log_degrees: List‹U8›, log_blowup: G, num_circuits: G, h: G) -> List‹Bucket› {
     match h {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ => match circ_has_height(log_degrees, log_blowup, num_circuits, 0, h) {
         0 => build_buckets(log_degrees, log_blowup, num_circuits, h - 1),
-        _ => store(ListNode.Cons(
+        _ => List.Cons(store((
                Bucket.Mk(h, [1, 0], [0, 0]),
-               build_buckets(log_degrees, log_blowup, num_circuits, h - 1))),
+               build_buckets(log_degrees, log_blowup, num_circuits, h - 1)))),
       },
     }
   }
@@ -707,15 +707,15 @@ def pcs := ⟦
   -- (`ro_fold` threads its `alpha_pow`), and write it back.
   fn bucket_update(buckets: List‹Bucket›, lh: G, p_x: List‹Goldilocks›, p_z: List‹Ext›,
       q: Ext, alpha: Ext) -> List‹Bucket› {
-    match load(buckets) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(b, rest) =>
+    match buckets {
+      List.Nil => List.Nil,
+      List.Cons(__cell27) => let (b, rest) = load(__cell27);
         let Bucket.Mk(h, ap, ro) = b;
         match eq_zero(h - lh) {
           1 =>
             let (ro2, ap2) = ro_fold(p_x, p_z, q, alpha, ro, ap);
-            store(ListNode.Cons(Bucket.Mk(h, ap2, ro2), rest)),
-          _ => store(ListNode.Cons(b, bucket_update(rest, lh, p_x, p_z, q, alpha))),
+            List.Cons(store((Bucket.Mk(h, ap2, ro2), rest))),
+          _ => List.Cons(store((b, bucket_update(rest, lh, p_x, p_z, q, alpha)))),
         },
     }
   }
@@ -723,9 +723,9 @@ def pcs := ⟦
   -- 1 (a constant polynomial); then `(f(ζ) − f(x))/(ζ − x)` must be 0. Assert it
   -- (`open_input`'s `FinalPolyMismatch` guard). No-op if no such bucket exists.
   fn assert_blowup_zero(buckets: List‹Bucket›, log_blowup: G) -> G {
-    match load(buckets) {
-      ListNode.Nil => 1,
-      ListNode.Cons(b, rest) =>
+    match buckets {
+      List.Nil => 1,
+      List.Cons(__cell28) => let (b, rest) = load(__cell28);
         let Bucket.Mk(h, _ap, ro) = b;
         match eq_zero(h - log_blowup) {
           1 => assert_eq!(@eg_eq(ro, [0, 0]), 1); 1,
@@ -839,17 +839,17 @@ def pcs := ⟦
   -- ── per-batch input-MMCS matrix log-heights (`log_degree + log_blowup`) ────
   fn heights_all(log_degrees: List‹U8›, log_blowup: G, rem: G, i: G) -> List‹G› {
     match rem {
-      0 => store(ListNode.Nil),
-      _ => store(ListNode.Cons(to_field(list_lookup(log_degrees, i)) + log_blowup,
-                               heights_all(log_degrees, log_blowup, rem - 1, i + 1))),
+      0 => List.Nil,
+      _ => List.Cons(store((to_field(list_lookup(log_degrees, i)) + log_blowup,
+                               heights_all(log_degrees, log_blowup, rem - 1, i + 1)))),
     }
   }
   -- Max of a height list (0 when empty): Plonky3's
   -- `batch_heights.iter().max().unwrap_or(0)` for the per-batch index reduction.
   fn heights_max(hs: List‹G›) -> G {
-    match load(hs) {
-      ListNode.Nil => 0,
-      ListNode.Cons(h, rest) =>
+    match hs {
+      List.Nil => 0,
+      List.Cons(__cell29) => let (h, rest) = load(__cell29);
         let m = heights_max(rest);
         match u32_less_than(m, h) {
           0 => m,
@@ -859,12 +859,12 @@ def pcs := ⟦
   }
   fn heights_prep(log_degrees: List‹U8›, log_blowup: G, prep_indices: List‹OptIdx›, rem: G, i: G) -> List‹G› {
     match rem {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ => match list_lookup(prep_indices, i) {
         OptIdx.NoIdx => heights_prep(log_degrees, log_blowup, prep_indices, rem - 1, i + 1),
         OptIdx.SomeIdx(_j) =>
-          store(ListNode.Cons(to_field(list_lookup(log_degrees, i)) + log_blowup,
-                              heights_prep(log_degrees, log_blowup, prep_indices, rem - 1, i + 1))),
+          List.Cons(store((to_field(list_lookup(log_degrees, i)) + log_blowup,
+                              heights_prep(log_degrees, log_blowup, prep_indices, rem - 1, i + 1)))),
       },
     }
   }
@@ -879,15 +879,15 @@ def pcs := ⟦
   }
   -- Flatten two ext evals to the 4 base coords of the ExtensionMmcs leaf row.
   fn flatten2(e0: Ext, e1: Ext) -> List‹U64› {
-    store(ListNode.Cons(@gl_to_bytes(e0[0]), store(ListNode.Cons(@gl_to_bytes(e0[1]),
-      store(ListNode.Cons(@gl_to_bytes(e1[0]), store(ListNode.Cons(@gl_to_bytes(e1[1]), store(ListNode.Nil)))))))))
+    List.Cons(store((@gl_to_bytes(e0[0]), List.Cons(store((@gl_to_bytes(e0[1]),
+      List.Cons(store((@gl_to_bytes(e1[0]), List.Cons(store((@gl_to_bytes(e1[1]), List.Nil))))))))))))
   }
   -- Roll the next reduced opening into the folded eval when its height matches
   -- the new folded height: `folded += beta^(2^log_arity) · ro`  (log_arity = 1).
   fn rollin(folded: Ext, log_folded: G, beta: Ext, ro_rest: List‹Bucket›) -> (Ext, List‹Bucket›) {
-    match load(ro_rest) {
-      ListNode.Nil => (folded, ro_rest),
-      ListNode.Cons(b, rest) =>
+    match ro_rest {
+      List.Nil => (folded, ro_rest),
+      List.Cons(__cell30) => let (b, rest) = load(__cell30);
         let Bucket.Mk(h, _ap, ro) = b;
         match eq_zero(h - log_folded) {
           1 => (@eg_add(folded, @eg_mul(ext_exp_pow2(beta, 1), ro)), rest),
@@ -898,26 +898,26 @@ def pcs := ⟦
   fn verify_query(folded: Ext, betas: List‹Ext›, comms: List‹MerkleCap›,
       openings: List‹CommitPhaseProofStep›, domidx: List‹G›, log_cur: G,
       ro_rest: List‹Bucket›, log_final: G) -> Ext {
-    match load(openings) {
-      ListNode.Nil =>
+    match openings {
+      List.Nil =>
         -- must have folded down to exactly the final domain size, and every
         -- reduced opening must have been rolled in (FinalFoldHeightMismatch /
         -- UnconsumedReducedOpenings).
         assert_eq!(eq_zero(log_cur - log_final), 1);
         assert_eq!(list_length(ro_rest), 0);
         folded,
-      ListNode.Cons(op, op_rest) =>
-        let &ListNode.Cons(beta, beta_rest) = betas;
-        let &ListNode.Cons(comm, comm_rest) = comms;
+      List.Cons(__cell31) => let (op, op_rest) = load(__cell31);
+        let List.Cons(__cell38) = betas; let (beta, beta_rest) = load(__cell38);
+        let List.Cons(__cell39) = comms; let (comm, comm_rest) = load(__cell39);
         let CommitPhaseProofStep.Mk(_la, sibs, oproof) = op;
         -- arity 2 ⇒ exactly arity-1 = 1 sibling (SiblingValuesLengthMismatch).
         assert_eq!(list_length(sibs), 1);
-        let &ListNode.Cons(ibit, idrest) = domidx;     -- index_in_group = LSB
+        let List.Cons(__cell40) = domidx; let (ibit, idrest) = load(__cell40);     -- index_in_group = LSB
         let log_folded = log_cur - 1;
         let (e0, e1) = recon_evals(ibit, folded, list_lookup(sibs, 0));
         -- authenticate the sibling pair against this round's commitment
-        assert_eq!(mmcs_verify(comm, store(ListNode.Cons(flatten2(e0, e1), store(ListNode.Nil))),
-          store(ListNode.Cons(log_folded, store(ListNode.Nil))), idrest, oproof, log_folded), 1);
+        assert_eq!(mmcs_verify(comm, List.Cons(store((flatten2(e0, e1), List.Nil))),
+          List.Cons(store((log_folded, List.Nil))), idrest, oproof, log_folded), 1);
         let folded1 = fri_fold2(idrest, log_folded, beta, e0, e1);
         let (folded2, ro_rest2) = rollin(folded1, log_folded, beta, ro_rest);
         verify_query(folded2, beta_rest, comm_rest, op_rest, idrest, log_folded, ro_rest2, log_final),
@@ -960,7 +960,7 @@ def pcs := ⟦
     let _cz = assert_blowup_zero(buckets, log_blowup);
     -- the first reduced opening must sit at log_global_max_height
     -- (InitialReducedOpeningHeightMismatch).
-    let &ListNode.Cons(b0, ro_rest) = buckets;
+    let List.Cons(__cell41) = buckets; let (b0, ro_rest) = load(__cell41);
     let Bucket.Mk(h0, _ap0, folded_start) = b0;
     assert_eq!(eq_zero(h0 - log_gmax), 1);
     let folded = verify_query(folded_start, betas, commit_phase_commits, commit_phase_openings, idxbits, log_gmax, ro_rest, log_blowup);
@@ -978,9 +978,9 @@ def pcs := ⟦
       log_degrees: List‹U8›, zeta: Ext, num_circuits: G, log_blowup: G, log_gmax: G,
       betas: List‹Ext›, commit_phase_commits: List‹MerkleCap›, final_poly: List‹Ext›,
       num_rounds: G) -> G {
-    match load(query_proofs) {
-      ListNode.Nil => 1,
-      ListNode.Cons(qp, rest) =>
+    match query_proofs {
+      List.Nil => 1,
+      List.Cons(__cell32) => let (qp, rest) = load(__cell32);
         let (idxbits, input2, output2) = ch_sample_bits(input, output, log_gmax);
         let _q = verify_one_query(idxbits, qp, alpha, stage1, stage2, q_opened, prep_opt,
           s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, num_circuits,
@@ -1011,15 +1011,15 @@ def pcs := ⟦
     -- order), built as one front-to-back suffix + a single concat (the input
     -- is only ~32 bytes here — it collapses to the digest on every flush).
     let obs = round_onto(stage1, round_onto(stage2, round_onto(q_opened,
-      prep_onto(prep_opt, store(ListNode.Nil)))));
+      prep_onto(prep_opt, List.Nil))));
     let input = list_concat(post_zeta_input, obs);
     -- PCS batch-combination challenge α
-    let (a0, a1, input, _oa) = ch_sample_ext(input, store(ListNode.Nil));
+    let (a0, a1, input, _oa) = ch_sample_ext(input, List.Nil);
     let alpha = [@gl_val(a0), @gl_val(a1)];
     -- per-round FRI fold challenges β (with commit-phase PoW), then observe
     -- final_poly + the log-arity schedule.
     let (betas, input) = pcs_betas(input, commit_phase_commits, pw, commit_pow_bits);
-    let input = list_concat(input, ext_row_onto(final_poly, store(ListNode.Nil)));
+    let input = list_concat(input, ext_row_onto(final_poly, List.Nil));
     let input = obs_log_arities(input, commit_phase_commits);
     -- query-phase grinding: check_witness over the query PoW witness, sampled
     -- AFTER the log-arity schedule and BEFORE the query indices (the query
diff --git a/Ix/MultiStark/SystemDeserialize.lean b/Ix/MultiStark/SystemDeserialize.lean
index 6d629a4d..4f3c4dfc 100644
--- a/Ix/MultiStark/SystemDeserialize.lean
+++ b/Ix/MultiStark/SystemDeserialize.lean
@@ -108,8 +108,8 @@ def systemDeserialize := ⟦
   -- ==========================================================================
 
   fn read_vk_u8(s: ByteStream) -> (U8, ByteStream) {
-    match load(s) {
-      ListNode.Cons(byte, rest) => (byte, rest),
+    match s {
+      List.Cons(__cell1) => let (byte, rest) = load(__cell1); (byte, rest),
     }
   }
 
@@ -174,11 +174,11 @@ def systemDeserialize := ⟦
   }
   fn read_vk_cap_n(i: ByteStream, n: G) -> (MerkleCap, ByteStream) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (x, j) = read_vk_digest(i);
         let (rest, j2) = read_vk_cap_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
+        (List.Cons(store((x, rest))), j2),
     }
   }
 
@@ -225,22 +225,22 @@ def systemDeserialize := ⟦
 
   fn read_nodes_n(i: ByteStream, n: G) -> (List‹SysNode›, ByteStream) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (nd, i1) = read_node(i);
         let (rest, i2) = read_nodes_n(i1, n - 1);
-        (store(ListNode.Cons(nd, rest)), i2),
+        (List.Cons(store((nd, rest))), i2),
     }
   }
 
   -- A run of u16 NodeIds (constraint roots / lookup argument ids).
   fn read_node_ids_n(i: ByteStream, n: G) -> (List‹G›, ByteStream) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (id, i1) = read_vk_u16(i);
         let (rest, i2) = read_node_ids_n(i1, n - 1);
-        (store(ListNode.Cons(id, rest)), i2),
+        (List.Cons(store((id, rest))), i2),
     }
   }
 
@@ -252,11 +252,11 @@ def systemDeserialize := ⟦
   }
   fn read_sys_lookups_n(i: ByteStream, n: G) -> (List‹SysLookup›, ByteStream) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (x, j) = read_sys_lookup(i);
         let (rest, j2) = read_sys_lookups_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
+        (List.Cons(store((x, rest))), j2),
     }
   }
 
@@ -309,19 +309,19 @@ def systemDeserialize := ⟦
      [ccl, mdl, phl, pwl, mwl, s2wl, kl], c10)
   }
   fn cons_shape7(l: [U64; 7], tail: List‹U64›) -> List‹U64› {
-    store(ListNode.Cons(l[0], store(ListNode.Cons(l[1], store(ListNode.Cons(l[2],
-    store(ListNode.Cons(l[3], store(ListNode.Cons(l[4], store(ListNode.Cons(l[5],
-    store(ListNode.Cons(l[6], tail))))))))))))))
+    List.Cons(store((l[0], List.Cons(store((l[1], List.Cons(store((l[2],
+    List.Cons(store((l[3], List.Cons(store((l[4], List.Cons(store((l[5],
+    List.Cons(store((l[6], tail)))))))))))))))))))))
   }
   -- Returns the circuits plus their shape limbs (`observe_shape` order: each
   -- circuit's 7 metadata words; the count limb is consed by `read_system`).
   fn read_sys_circuits_n(i: ByteStream, n: G) -> (List‹SysCircuit›, List‹U64›, ByteStream) {
     match n {
-      0 => (store(ListNode.Nil), store(ListNode.Nil), i),
+      0 => (List.Nil, List.Nil, i),
       _ =>
         let (x, xl, j) = read_sys_circuit(i);
         let (rest, lrest, j2) = read_sys_circuits_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), cons_shape7(xl, lrest), j2),
+        (List.Cons(store((x, rest))), cons_shape7(xl, lrest), j2),
     }
   }
 
@@ -342,13 +342,13 @@ def systemDeserialize := ⟦
   -- One u16 per circuit; 0xFFFF is the None sentinel.
   fn read_opt_idx_n(i: ByteStream, n: G) -> (List‹OptIdx›, ByteStream) {
     match n {
-      0 => (store(ListNode.Nil), i),
+      0 => (List.Nil, i),
       _ =>
         let (v, j) = read_vk_u16(i);
         let (rest, j2) = read_opt_idx_n(j, n - 1);
         match v {
-          65535 => (store(ListNode.Cons(OptIdx.NoIdx, rest)), j2),
-          _ => (store(ListNode.Cons(OptIdx.SomeIdx(v), rest)), j2),
+          65535 => (List.Cons(store((OptIdx.NoIdx, rest))), j2),
+          _ => (List.Cons(store((OptIdx.SomeIdx(v), rest))), j2),
         },
     }
   }
@@ -364,9 +364,9 @@ def systemDeserialize := ⟦
     let (p5, l5, j5) = read_vk_u16_limb(j4);
     let (p6, l6, j6) = read_vk_u16_limb(j5);
     (SysParams.Mk(p0, p1, p2, p3, p4, p5, p6),
-     store(ListNode.Cons(l0, store(ListNode.Cons(l1, store(ListNode.Cons(l2,
-     store(ListNode.Cons(l3, store(ListNode.Cons(l4, store(ListNode.Cons(l5,
-     store(ListNode.Cons(l6, store(ListNode.Nil))))))))))))))),
+     List.Cons(store((l0, List.Cons(store((l1, List.Cons(store((l2,
+     List.Cons(store((l3, List.Cons(store((l4, List.Cons(store((l5,
+     List.Cons(store((l6, List.Nil))))))))))))))))))))),
      j6)
   }
 
@@ -379,7 +379,7 @@ def systemDeserialize := ⟦
     let (commit, j3) = read_opt_commit(j2);
     let (indices, j4) = read_opt_idx_n(j3, n);
     (Sys.Mk(params,
-            list_concat(plimbs, store(ListNode.Cons(nlimb, climbs))),
+            list_concat(plimbs, List.Cons(store((nlimb, climbs)))),
             circuits, commit, indices),
      j4)
   }
diff --git a/Ix/MultiStark/Tests.lean b/Ix/MultiStark/Tests.lean
index 21f3e09c..bb24b0bb 100644
--- a/Ix/MultiStark/Tests.lean
+++ b/Ix/MultiStark/Tests.lean
@@ -96,10 +96,10 @@ def tests := ⟦
   -- `0x0102030405060708` (8 LE bytes) must equal the reference `799146`
   -- (`pcs_challenger_ref` in `multi-stark/src/types.rs`).
   pub fn sample_bits_test() -> G {
-    let input = store(ListNode.Cons(8u8, store(ListNode.Cons(7u8, store(ListNode.Cons(6u8,
-      store(ListNode.Cons(5u8, store(ListNode.Cons(4u8, store(ListNode.Cons(3u8,
-      store(ListNode.Cons(2u8, store(ListNode.Cons(1u8, store(ListNode.Nil)))))))))))))))));
-    let (bits, _i, _o) = ch_sample_bits(input, store(ListNode.Nil), 20);
+    let input = List.Cons(store((8u8, List.Cons(store((7u8, List.Cons(store((6u8,
+      List.Cons(store((5u8, List.Cons(store((4u8, List.Cons(store((3u8,
+      List.Cons(store((2u8, List.Cons(store((1u8, List.Nil))))))))))))))))))))))));
+    let (bits, _i, _o) = ch_sample_bits(input, List.Nil, 20);
     assert_eq!(bits_to_num(bits), 1019203);
     1
   }
@@ -112,9 +112,9 @@ def tests := ⟦
     -- post-ζ input buffer = observe V0 then V1 (forward / observation order).
     let v0 = [8u8, 7u8, 6u8, 5u8, 4u8, 3u8, 2u8, 1u8];     -- 0x0102030405060708
     let v1 = [136u8, 119u8, 102u8, 85u8, 68u8, 51u8, 34u8, 17u8]; -- 0x1122334455667788
-    let input = snoc_b8(snoc_b8(store(ListNode.Nil), v0), v1);
+    let input = snoc_b8(snoc_b8(List.Nil, v0), v1);
     -- α_pcs (output empty ⇒ flush), then α_fri (CONSECUTIVE ⇒ thread output).
-    let (apcs, input, o1) = pcs_sample_ext(input, store(ListNode.Nil));
+    let (apcs, input, o1) = pcs_sample_ext(input, List.Nil);
     let (afri, input, o2) = pcs_sample_ext(input, o1);
     assert_eq!(apcs[0], 17795849114622667264);
     assert_eq!(apcs[1], 4116843485681689527);
@@ -123,7 +123,7 @@ def tests := ⟦
     -- observe commit (clears output), sample β.
     let v2 = [239u8, 190u8, 173u8, 222u8, 0u8, 0u8, 0u8, 0u8]; -- 0x00000000deadbeef
     let (input, _oc) = ch_observe_val(input, v2);
-    let (beta, input, _ob) = pcs_sample_ext(input, store(ListNode.Nil));
+    let (beta, input, _ob) = pcs_sample_ext(input, List.Nil);
     assert_eq!(beta[0], 12096272534537655203);
     assert_eq!(beta[1], 11431251745744402868);
     -- observe final_poly coeff + log_arity (each a Val), then sample the index.
@@ -131,7 +131,7 @@ def tests := ⟦
     let v4 = [2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8];     -- 0x0000000000000002
     let (input, _o3) = ch_observe_val(input, v3);
     let (input, _o4) = ch_observe_val(input, v4);
-    let (bits, _bi, _bo) = ch_sample_bits(input, store(ListNode.Nil), 20);
+    let (bits, _bi, _bo) = ch_sample_bits(input, List.Nil, 20);
     assert_eq!(bits_to_num(bits), 458922);
     1
   }
@@ -143,8 +143,8 @@ def tests := ⟦
   -- Self-test: arity-2 fold at index 5, log_height 3 vs the `fri_fold_ref`
   -- reference (computed by the real `TwoAdicFriFolding::fold_row`).
   pub fn fri_fold_test() -> G {
-    let index_bits = store(ListNode.Cons(1, store(ListNode.Cons(0,
-                       store(ListNode.Cons(1, store(ListNode.Nil)))))));
+    let index_bits = List.Cons(store((1, List.Cons(store((0,
+                       List.Cons(store((1, List.Nil)))))))));
     let e0 = [@gl_val([17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8, 17u8]),
               @gl_val([34u8, 34u8, 34u8, 34u8, 34u8, 34u8, 34u8, 34u8])];
     let e1 = [@gl_val([51u8, 51u8, 51u8, 51u8, 51u8, 51u8, 51u8, 51u8]),
@@ -160,8 +160,8 @@ def tests := ⟦
   -- Self-test vs `ro_fold_ref`: x at index 5 / log_height 3, then accumulate
   -- (p_z − p_x)/(z − x) over 3 columns with alpha powers.
   pub fn ro_fold_test() -> G {
-    let index_bits = store(ListNode.Cons(1, store(ListNode.Cons(0,
-                       store(ListNode.Cons(1, store(ListNode.Nil)))))));
+    let index_bits = List.Cons(store((1, List.Cons(store((0,
+                       List.Cons(store((1, List.Nil)))))))));
     let x = ro_x(index_bits, 3);
     assert_eq!(x, 117440512);
     let z = [@gl_val([154u8, 120u8, 86u8, 52u8, 18u8, 0u8, 0u8, 0u8]),
@@ -171,13 +171,13 @@ def tests := ⟦
     let px0 = @gl_val([11u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
     let px1 = @gl_val([22u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
     let px2 = @gl_val([33u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    let p_x = store(ListNode.Cons(px0, store(ListNode.Cons(px1,
-                store(ListNode.Cons(px2, store(ListNode.Nil)))))));
+    let p_x = List.Cons(store((px0, List.Cons(store((px1,
+                List.Cons(store((px2, List.Nil)))))))));
     let pz0 = [@gl_val([100u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), @gl_val([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
     let pz1 = [@gl_val([200u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), @gl_val([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
     let pz2 = [@gl_val([44u8, 1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), @gl_val([3u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8])];
-    let p_z = store(ListNode.Cons(pz0, store(ListNode.Cons(pz1,
-                store(ListNode.Cons(pz2, store(ListNode.Nil)))))));
+    let p_z = List.Cons(store((pz0, List.Cons(store((pz1,
+                List.Cons(store((pz2, List.Nil)))))))));
     let q = @eg_inverse(@eg_sub(z, [x, 0]));
     let (ro, _ap) = ro_fold(p_x, p_z, q, alpha, [0, 0], [1, 0]);
     assert_eq!(ro[0], 7130765474285082575);
@@ -198,8 +198,8 @@ def tests := ⟦
   -- `[i+1, i+2, …, n]` as a `List‹U64›`.
   fn build_range(i: G, n: G) -> List‹U64› {
     match n - i {
-      0 => store(ListNode.Nil),
-      _ => store(ListNode.Cons(u64_of(u8_from_field_unsafe(i + 1)), build_range(i + 1, n))),
+      0 => List.Nil,
+      _ => List.Cons(store((u64_of(u8_from_field_unsafe(i + 1)), build_range(i + 1, n)))),
     }
   }
   fn assert_digest(d: Digest, e0: G, e1: G, e2: G, e3: G) -> G {
@@ -240,15 +240,15 @@ def tests := ⟦
   -- yields a different (rejected) root.
   pub fn pcs_merkle_test() -> G {
     -- opened rows (matrix order): m0 row5, m1 row2, m2 row1.
-    let row0 = store(ListNode.Cons(u64_of(11u8), store(ListNode.Cons(u64_of(12u8), store(ListNode.Nil)))));
-    let row1 = store(ListNode.Cons(u64_of(107u8), store(ListNode.Cons(u64_of(108u8),
-                 store(ListNode.Cons(u64_of(109u8), store(ListNode.Nil)))))));
-    let row2 = store(ListNode.Cons(u64_of(202u8), store(ListNode.Nil)));
-    let rows = store(ListNode.Cons(row0, store(ListNode.Cons(row1,
-                 store(ListNode.Cons(row2, store(ListNode.Nil)))))));
+    let row0 = List.Cons(store((u64_of(11u8), List.Cons(store((u64_of(12u8), List.Nil))))));
+    let row1 = List.Cons(store((u64_of(107u8), List.Cons(store((u64_of(108u8),
+                 List.Cons(store((u64_of(109u8), List.Nil)))))))));
+    let row2 = List.Cons(store((u64_of(202u8), List.Nil)));
+    let rows = List.Cons(store((row0, List.Cons(store((row1,
+                 List.Cons(store((row2, List.Nil)))))))));
     -- log-heights and path bits (index 5 = 0b101, LSB first).
-    let lhs = store(ListNode.Cons(3, store(ListNode.Cons(2, store(ListNode.Cons(1, store(ListNode.Nil)))))));
-    let ibits = store(ListNode.Cons(1, store(ListNode.Cons(0, store(ListNode.Cons(1, store(ListNode.Nil)))))));
+    let lhs = List.Cons(store((3, List.Cons(store((2, List.Cons(store((1, List.Nil)))))))));
+    let ibits = List.Cons(store((1, List.Cons(store((0, List.Cons(store((1, List.Nil)))))))));
     -- authentication path SIB0, SIB1, SIB2 (each a Digest = [U64; 4]).
     let sib0 = [[229u8, 114u8, 223u8, 248u8, 35u8, 4u8, 112u8, 11u8],
                 [133u8, 106u8, 85u8, 90u8, 195u8, 164u8, 85u8, 141u8],
@@ -262,21 +262,21 @@ def tests := ⟦
                 [220u8, 192u8, 39u8, 69u8, 198u8, 24u8, 123u8, 147u8],
                 [63u8, 5u8, 74u8, 98u8, 77u8, 73u8, 181u8, 252u8],
                 [134u8, 86u8, 33u8, 32u8, 240u8, 13u8, 134u8, 153u8]];
-    let proof = store(ListNode.Cons(sib0, store(ListNode.Cons(sib1,
-                  store(ListNode.Cons(sib2, store(ListNode.Nil)))))));
+    let proof = List.Cons(store((sib0, List.Cons(store((sib1,
+                  List.Cons(store((sib2, List.Nil)))))))));
     let (root, capidx) = mmcs_root(rows, lhs, ibits, proof, 3);
     assert_eq!(capidx, 0);
     assert_eq!(assert_digest(root, 4722047561722553901, 2839201037098837684,
                                    4926058068911485563, 1219861215742277604), 1);
     -- tamper: perturb m0's first opened value → root must change.
-    let bad0 = store(ListNode.Cons(u64_of(99u8), store(ListNode.Cons(u64_of(12u8), store(ListNode.Nil)))));
-    let bad_rows = store(ListNode.Cons(bad0, store(ListNode.Cons(row1,
-                     store(ListNode.Cons(row2, store(ListNode.Nil)))))));
-    let cap = store(ListNode.Cons([[45u8, 230u8, 248u8, 40u8, 61u8, 21u8, 136u8, 65u8],
+    let bad0 = List.Cons(store((u64_of(99u8), List.Cons(store((u64_of(12u8), List.Nil))))));
+    let bad_rows = List.Cons(store((bad0, List.Cons(store((row1,
+                     List.Cons(store((row2, List.Nil)))))))));
+    let cap = List.Cons(store(([[45u8, 230u8, 248u8, 40u8, 61u8, 21u8, 136u8, 65u8],
                                    [180u8, 102u8, 50u8, 238u8, 76u8, 222u8, 102u8, 39u8],
                                    [123u8, 114u8, 106u8, 220u8, 182u8, 223u8, 92u8, 68u8],
                                    [228u8, 55u8, 152u8, 7u8, 80u8, 209u8, 237u8, 16u8]],
-                    store(ListNode.Nil)));
+                    List.Nil)));
     assert_eq!(mmcs_verify(cap, rows, lhs, ibits, proof, 3), 1);
     assert_eq!(mmcs_verify(cap, bad_rows, lhs, ibits, proof, 3), 0);
     1
@@ -290,18 +290,18 @@ def tests := ⟦
   -- with the index so lane- or word-order bugs change the digest.
   fn lane_test_row(n: G) -> List‹U64› {
     match n {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ =>
         -- n mod 256, valid for n ≤ 511 (largest size used below is 500).
         let lo = u8_from_field_unsafe(n - 256 * u32_less_than(255, n));
-        store(ListNode.Cons([lo, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8],
-                            lane_test_row(n - 1))),
+        List.Cons(store(([lo, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8],
+                            lane_test_row(n - 1)))),
     }
   }
   fn lane_hash_check(n: G) -> G {
     let row = lane_test_row(n);
     digest_eq(b3_to_digest(b3_lanes(row)),
-              b3_to_digest(blake3(b3_row_onto(row, store(ListNode.Nil)))))
+              b3_to_digest(blake3(b3_row_onto(row, List.Nil))))
   }
   pub fn lane_hash_test() -> G {
     lane_hash_check(0) * lane_hash_check(1) * lane_hash_check(7)
@@ -317,9 +317,9 @@ def tests := ⟦
   -- multi-chunk total (layer fold). Rows reuse `lane_test_row`'s varied
   -- bytes.
   fn rows_test_rows(spec: List‹G›) -> List‹List‹U64›› {
-    match load(spec) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(n, rest) => store(ListNode.Cons(lane_test_row(n), rows_test_rows(rest))),
+    match spec {
+      List.Nil => List.Nil,
+      List.Cons(__cell1) => let (n, rest) = load(__cell1); List.Cons(store((lane_test_row(n), rows_test_rows(rest)))),
     }
   }
   fn rows_hash_check(spec: List‹G›, lhs: List‹G›, target: G) -> G {
@@ -327,9 +327,9 @@ def tests := ⟦
     digest_eq(b3_to_digest(b3_rows(select_rows(rows, lhs, target))),
               mmcs_hash_row(canon_lanes(concat_at(rows, lhs, target))))
   }
-  fn g1(a: G) -> List‹G› { store(ListNode.Cons(a, store(ListNode.Nil))) }
-  fn g2(a: G, b: G) -> List‹G› { store(ListNode.Cons(a, g1(b))) }
-  fn g3(a: G, b: G, c: G) -> List‹G› { store(ListNode.Cons(a, g2(b, c))) }
+  fn g1(a: G) -> List‹G› { List.Cons(store((a, List.Nil))) }
+  fn g2(a: G, b: G) -> List‹G› { List.Cons(store((a, g1(b)))) }
+  fn g3(a: G, b: G, c: G) -> List‹G› { List.Cons(store((a, g2(b, c)))) }
   pub fn rows_hash_test() -> G {
     rows_hash_check(g3(3, 5, 2), g3(7, 7, 7), 7)
       * rows_hash_check(g3(3, 5, 2), g3(7, 7, 7), 5)
@@ -358,10 +358,10 @@ def tests := ⟦
   }
   fn io_test_bytes(n: G, off: G) -> ByteStream {
     match n {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ =>
         let [b] = io_read(9, off, 1);
-        store(ListNode.Cons(u8_from_field_unsafe(b), io_test_bytes(n - 1, off + 1))),
+        List.Cons(store((u8_from_field_unsafe(b), io_test_bytes(n - 1, off + 1)))),
     }
   }
   fn io_hash_check(n: G, off: G) -> (G, G) {
diff --git a/Ix/MultiStark/Verifier.lean b/Ix/MultiStark/Verifier.lean
index 060d58c3..bd499484 100644
--- a/Ix/MultiStark/Verifier.lean
+++ b/Ix/MultiStark/Verifier.lean
@@ -75,11 +75,11 @@ def verifier := ⟦
   -- element (Rust: `intermediate_accumulators.last() == Some(ExtVal::ZERO)`).
   -- The empty list returns 0 (there is no last element to balance).
   fn last_acc_is_zero(accs: List‹Ext›) -> G {
-    match load(accs) {
-      ListNode.Nil => 0,
-      ListNode.Cons(e, rest) =>
-        match load(rest) {
-          ListNode.Nil => ext_is_zero(e),
+    match accs {
+      List.Nil => 0,
+      List.Cons(__cell1) => let (e, rest) = load(__cell1);
+        match rest {
+          List.Nil => ext_is_zero(e),
           _ => last_acc_is_zero(rest),
         },
     }
@@ -99,9 +99,9 @@ def verifier := ⟦
 
   -- Cons 8 bytes (LSB-first) of `b` onto `tail` (one byte list segment).
   fn b8_onto(b: [U8; 8], tail: ByteStream) -> ByteStream {
-    store(ListNode.Cons(b[0], store(ListNode.Cons(b[1], store(ListNode.Cons(b[2],
-    store(ListNode.Cons(b[3], store(ListNode.Cons(b[4], store(ListNode.Cons(b[5],
-    store(ListNode.Cons(b[6], store(ListNode.Cons(b[7], tail))))))))))))))))
+    List.Cons(store((b[0], List.Cons(store((b[1], List.Cons(store((b[2],
+    List.Cons(store((b[3], List.Cons(store((b[4], List.Cons(store((b[5],
+    List.Cons(store((b[6], List.Cons(store((b[7], tail))))))))))))))))))))))))
   }
 
   -- A digest = `[u64; 4]` = 32 bytes (each limb little-endian) onto `tail`.
@@ -111,42 +111,42 @@ def verifier := ⟦
 
   -- A commitment (`MerkleCap` = `Vec<Digest>`): all digest bytes, onto `tail`.
   fn cap_onto(cap: MerkleCap, tail: ByteStream) -> ByteStream {
-    match load(cap) {
-      ListNode.Nil => tail,
-      ListNode.Cons(d, rest) => digest_onto(d, cap_onto(rest, tail)),
+    match cap {
+      List.Nil => tail,
+      List.Cons(__cell2) => let (d, rest) = load(__cell2); digest_onto(d, cap_onto(rest, tail)),
     }
   }
 
   -- Observe `log_degrees`: each is a `Val::from_u8`, i.e. 8 LE bytes `[ld,0,…]`.
   fn log_degrees_onto(lds: List‹U8›, tail: ByteStream) -> ByteStream {
-    match load(lds) {
-      ListNode.Nil => tail,
-      ListNode.Cons(ld, rest) =>
+    match lds {
+      List.Nil => tail,
+      List.Cons(__cell3) => let (ld, rest) = load(__cell3);
         b8_onto([ld, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], log_degrees_onto(rest, tail)),
     }
   }
 
   -- Reverse `l` onto `acc` (used to put a hash output into pop order).
   fn rev_onto(l: ByteStream, acc: ByteStream) -> ByteStream {
-    match load(l) {
-      ListNode.Nil => acc,
-      ListNode.Cons(b, rest) => rev_onto(rest, store(ListNode.Cons(b, acc))),
+    match l {
+      List.Nil => acc,
+      List.Cons(__cell4) => let (b, rest) = load(__cell4); rev_onto(rest, List.Cons(store((b, acc)))),
     }
   }
 
   -- Sample one byte. If `output` is empty, flush: hash the `input` buffer, set
   -- the new input to the 32 hash bytes, and refill `output` (in pop order).
   fn ch_sample_byte(input: ByteStream, output: ByteStream) -> (U8, ByteStream, ByteStream) {
-    match load(output) {
-      ListNode.Cons(b, rest) => (b, input, rest),
-      ListNode.Nil =>
+    match output {
+      List.Cons(__cell5) => let (b, rest) = load(__cell5); (b, input, rest),
+      List.Nil =>
         -- `HashChallenger<u8, Blake3, 32>` flush: hash the `input` buffer with
         -- blake3; `b3_flatten_onto` (Pcs.lean) gives the 32 output bytes, popped
         -- from the END (rev), with the `input := output := hash` update.
         let h = blake3(input);
-        let fwd = b3_flatten_onto(h, store(ListNode.Nil));
-        let rev = rev_onto(fwd, store(ListNode.Nil));
-        let &ListNode.Cons(b, rest) = rev;
+        let fwd = b3_flatten_onto(h, List.Nil);
+        let rev = rev_onto(fwd, List.Nil);
+        let List.Cons(__cell23) = rev; let (b, rest) = load(__cell23);
         (b, fwd, rest),
     }
   }
@@ -190,9 +190,9 @@ def verifier := ⟦
 
   -- Prepend the 8 elements of `d` onto `tail` (generic list helper).
   fn cons8(d: [G; 8], tail: List‹G›) -> List‹G› {
-    store(ListNode.Cons(d[0], store(ListNode.Cons(d[1], store(ListNode.Cons(d[2],
-    store(ListNode.Cons(d[3], store(ListNode.Cons(d[4], store(ListNode.Cons(d[5],
-    store(ListNode.Cons(d[6], store(ListNode.Cons(d[7], tail))))))))))))))))
+    List.Cons(store((d[0], List.Cons(store((d[1], List.Cons(store((d[2],
+    List.Cons(store((d[3], List.Cons(store((d[4], List.Cons(store((d[5],
+    List.Cons(store((d[6], List.Cons(store((d[7], tail))))))))))))))))))))))))
   }
 
   -- `sample_bits(n)` (FRI query index). `SerializingChallenger64::sample_bits`
@@ -208,14 +208,14 @@ def verifier := ⟦
     cons8(u8_bit_decomposition(bytes[4]),
     cons8(u8_bit_decomposition(bytes[5]),
     cons8(u8_bit_decomposition(bytes[6]),
-    cons8(u8_bit_decomposition(bytes[7]), store(ListNode.Nil)))))))))
+    cons8(u8_bit_decomposition(bytes[7]), List.Nil))))))))
   }
   fn take_bits(bits: List‹G›, n: G) -> List‹G› {
     match n {
-      0 => store(ListNode.Nil),
+      0 => List.Nil,
       _ =>
-        let &ListNode.Cons(b, rest) = bits;
-        store(ListNode.Cons(b, take_bits(rest, n - 1))),
+        let List.Cons(__cell24) = bits; let (b, rest) = load(__cell24);
+        List.Cons(store((b, take_bits(rest, n - 1)))),
     }
   }
   fn ch_sample_bits(input: ByteStream, output: ByteStream, n: G)
@@ -229,11 +229,11 @@ def verifier := ⟦
   -- first hashed, matching `blake3`'s absorption order), so an observation
   -- appends — `b8_onto` PREPENDS, hence the `list_concat`.
   fn snoc_b8(input: ByteStream, b: [U8; 8]) -> ByteStream {
-    list_concat(input, b8_onto(b, store(ListNode.Nil)))
+    list_concat(input, b8_onto(b, List.Nil))
   }
   -- Append (observe) a commitment (`MerkleCap`) at the end of the buffer.
   fn snoc_cap(input: ByteStream, cap: MerkleCap) -> ByteStream {
-    list_concat(input, cap_onto(cap, store(ListNode.Nil)))
+    list_concat(input, cap_onto(cap, List.Nil))
   }
   -- The intermediate accumulators as a prepend-built stream, in order — each
   -- an `observe_algebra_element`: two canonical 8-LE-byte limbs. (`read_ext`
@@ -241,9 +241,9 @@ def verifier := ⟦
   -- Prepend-composed so observing all of them is one `list_concat`, not a
   -- per-element re-walk of the input buffer.
   fn accs_onto(accs: List‹Ext›, tail: ByteStream) -> ByteStream {
-    match load(accs) {
-      ListNode.Nil => tail,
-      ListNode.Cons(e, rest) => b8_onto(@gl_to_bytes(e[0]), b8_onto(@gl_to_bytes(e[1]), accs_onto(rest, tail))),
+    match accs {
+      List.Nil => tail,
+      List.Cons(__cell6) => let (e, rest) = load(__cell6); b8_onto(@gl_to_bytes(e[0]), b8_onto(@gl_to_bytes(e[1]), accs_onto(rest, tail))),
     }
   }
 
@@ -260,7 +260,7 @@ def verifier := ⟦
   -- Observe one `Val` (8 LE bytes): append to `input`, CLEAR `output` (any
   -- leftover sampled bytes are discarded), per `HashChallenger::observe`.
   fn ch_observe_val(input: ByteStream, v: U64) -> (ByteStream, ByteStream) {
-    (snoc_b8(input, v), store(ListNode.Nil))
+    (snoc_b8(input, v), List.Nil)
   }
 
   -- Sample a degree-2 extension element, threading BOTH challenger buffers so a
@@ -275,17 +275,17 @@ def verifier := ⟦
 
   -- Append a claim's values (each `Val` as 8 LE bytes) onto `tail`, in order.
   fn claim_vals_onto(vals: List‹U64›, tail: ByteStream) -> ByteStream {
-    match load(vals) {
-      ListNode.Nil => tail,
-      ListNode.Cons(v, rest) => b8_onto(v, claim_vals_onto(rest, tail)),
+    match vals {
+      List.Nil => tail,
+      List.Cons(__cell7) => let (v, rest) = load(__cell7); b8_onto(v, claim_vals_onto(rest, tail)),
     }
   }
   -- Each claim, length-prefixed: `observe(Val::from_usize(claim.len()))` then
   -- `observe_slice(claim)`.
   fn claims_each_onto(claims: List‹List‹U64››, tail: ByteStream) -> ByteStream {
-    match load(claims) {
-      ListNode.Nil => tail,
-      ListNode.Cons(c, rest) =>
+    match claims {
+      List.Nil => tail,
+      List.Cons(__cell8) => let (c, rest) = load(__cell8);
         b8_onto(list_length_u64(c), claim_vals_onto(c, claims_each_onto(rest, tail))),
     }
   }
@@ -298,19 +298,19 @@ def verifier := ⟦
   -- `b"multi-stark/v0"` — the domain-separation tag the challenger seed
   -- starts with (`GoldilocksBlake3Config::new`).
   fn seed_tag_onto(tail: ByteStream) -> ByteStream {
-    store(ListNode.Cons(109u8, store(ListNode.Cons(117u8, store(ListNode.Cons(108u8,
-    store(ListNode.Cons(116u8, store(ListNode.Cons(105u8, store(ListNode.Cons(45u8,
-    store(ListNode.Cons(115u8, store(ListNode.Cons(116u8, store(ListNode.Cons(97u8,
-    store(ListNode.Cons(114u8, store(ListNode.Cons(107u8, store(ListNode.Cons(47u8,
-    store(ListNode.Cons(118u8, store(ListNode.Cons(48u8,
-    tail))))))))))))))))))))))))))))
+    List.Cons(store((109u8, List.Cons(store((117u8, List.Cons(store((108u8,
+    List.Cons(store((116u8, List.Cons(store((105u8, List.Cons(store((45u8,
+    List.Cons(store((115u8, List.Cons(store((116u8, List.Cons(store((97u8,
+    List.Cons(store((114u8, List.Cons(store((107u8, List.Cons(store((47u8,
+    List.Cons(store((118u8, List.Cons(store((48u8,
+    tail))))))))))))))))))))))))))))))))))))))))))
   }
   -- Raw u64 wire words (protocol parameters + system shape), each as its 8 LE
   -- bytes, in order.
   fn limbs_onto(ls: List‹U64›, tail: ByteStream) -> ByteStream {
-    match load(ls) {
-      ListNode.Nil => tail,
-      ListNode.Cons(l, rest) => b8_onto(l, limbs_onto(rest, tail)),
+    match ls {
+      List.Nil => tail,
+      List.Cons(__cell9) => let (l, rest) = load(__cell9); b8_onto(l, limbs_onto(rest, tail)),
     }
   }
 
@@ -318,7 +318,7 @@ def verifier := ⟦
   -- (observes nothing) when there is none.
   fn opt_commit_cap(commit: OptCommit) -> MerkleCap {
     match commit {
-      OptCommit.NoCommit => store(ListNode.Nil),
+      OptCommit.NoCommit => List.Nil,
       OptCommit.SomeCommit(c) => c,
     }
   }
@@ -334,7 +334,7 @@ def verifier := ⟦
   --   observe quotient; sample ζ.
   -- `observe` clears the challenger's output buffer, and every sample here is
   -- preceded by an observe, so each `ch_sample_ext` re-flushes from an empty
-  -- output (hence the `store(ListNode.Nil)` output argument each time).
+  -- output (hence the `List.Nil` output argument each time).
   -- Every sample is rejection-sampled (`ch_sample_field` inside
   -- `ch_sample_ext`), so a limb in the band `[p, 2⁶⁴)` is redrawn exactly as in
   -- the reference challenger, and the limbs observed back are canonical.
@@ -344,9 +344,9 @@ def verifier := ⟦
   -- values), which clears `output` anyway.
   -- Each activation bit as an observed `Val` (8 LE bytes, 0 or 1).
   fn active_onto(active: List‹G›, tail: ByteStream) -> ByteStream {
-    match load(active) {
-      ListNode.Nil => tail,
-      ListNode.Cons(b, rest) =>
+    match active {
+      List.Nil => tail,
+      List.Cons(__cell10) => let (b, rest) = load(__cell10);
         b8_onto([u8_from_field_unsafe(b), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
                 active_onto(rest, tail)),
     }
@@ -359,7 +359,7 @@ def verifier := ⟦
     -- (`tlimbs`, from the verifying key), the activation bitmap, prep,
     -- stage_1, log_degrees, claims. Built inner-to-outer with the prepend
     -- helpers so the result is in forward (observation) order.
-    let input = claims_onto(claims, store(ListNode.Nil));
+    let input = claims_onto(claims, List.Nil);
     let input = log_degrees_onto(lds, input);
     let input = cap_onto(s1, input);
     let input = cap_onto(prep, input);
@@ -367,22 +367,22 @@ def verifier := ⟦
     let input = limbs_onto(tlimbs, input);
     let input = seed_tag_onto(input);
     -- sample lookup challenge, then observe it back (append)
-    let (l0, l1, input, _ol) = ch_sample_ext(input, store(ListNode.Nil));
+    let (l0, l1, input, _ol) = ch_sample_ext(input, List.Nil);
     let input = snoc_b8(snoc_b8(input, l0), l1);
     -- sample fingerprint challenge, then observe it back
-    let (f0, f1, input, _of) = ch_sample_ext(input, store(ListNode.Nil));
+    let (f0, f1, input, _of) = ch_sample_ext(input, List.Nil);
     let input = snoc_b8(snoc_b8(input, f0), f1);
     -- observe stage_2 commitment
     let input = snoc_cap(input, s2);
     -- observe the intermediate accumulators (public values entering the
     -- constraints; α and ζ must depend on them directly)
-    let input = list_concat(input, accs_onto(accs, store(ListNode.Nil)));
+    let input = list_concat(input, accs_onto(accs, List.Nil));
     -- sample constraint challenge α (not observed)
-    let (a0, a1, input, _oa) = ch_sample_ext(input, store(ListNode.Nil));
+    let (a0, a1, input, _oa) = ch_sample_ext(input, List.Nil);
     -- observe quotient commitment
     let input = snoc_cap(input, q);
     -- sample out-of-domain point ζ; keep the resulting `input` for the PCS phase
-    let (z0, z1, zinput, _oz) = ch_sample_ext(input, store(ListNode.Nil));
+    let (z0, z1, zinput, _oz) = ch_sample_ext(input, List.Nil);
     ([@gl_val(l0), @gl_val(l1)],
      [@gl_val(f0), @gl_val(f1)],
      [@gl_val(a0), @gl_val(a1)],
@@ -535,11 +535,11 @@ def verifier := ⟦
   -- coordinates; fold consecutive pairs back into `stage_2_width` extension
   -- elements (Rust: `chunks_exact(2).map(from_ext_basis)`).
   fn reconstruct_ext_row(raw: List‹Ext›) -> List‹Ext› {
-    match load(raw) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(c0, t1) =>
-        let ListNode.Cons(c1, t2) = load(t1);
-        store(ListNode.Cons(from_ext_basis(c0, c1), reconstruct_ext_row(t2))),
+    match raw {
+      List.Nil => List.Nil,
+      List.Cons(__cell11) => let (c0, t1) = load(__cell11);
+        let List.Cons(__lcell1001) = t1; let (c1, t2) = load(__lcell1001);
+        List.Cons(store((from_ext_basis(c0, c1), reconstruct_ext_row(t2)))),
     }
   }
 
@@ -608,9 +608,9 @@ def verifier := ⟦
       main: List‹Ext›, main_next: List‹Ext›, prep: List‹Ext›, prep_next: List‹Ext›,
       s2: List‹Ext›, s2next: List‹Ext›, publics: List‹Ext›,
       isf: Ext, isl: Ext, ist: Ext) -> Ext {
-    match load(zeros) {
-      ListNode.Nil => acc,
-      ListNode.Cons(z, rest) =>
+    match zeros {
+      List.Nil => acc,
+      List.Cons(__cell12) => let (z, rest) = load(__cell12);
         let v = eval_at(nodes, z, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist);
         fold_roots(ood_fold(acc, alpha, v), alpha, rest, nodes,
                    main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist),
@@ -642,9 +642,9 @@ def verifier := ⟦
       main: List‹Ext›, main_next: List‹Ext›, prep: List‹Ext›, prep_next: List‹Ext›,
       s2: List‹Ext›, s2next: List‹Ext›, publics: List‹Ext›,
       isf: Ext, isl: Ext, ist: Ext) -> (Ext, Ext) {
-    match load(args) {
-      ListNode.Nil => ([0, 0], [0, 0]),
-      ListNode.Cons(a, rest) =>
+    match args {
+      List.Nil => ([0, 0], [0, 0]),
+      List.Cons(__cell13) => let (a, rest) = load(__cell13);
         let (f0, f1) = logup_fingerprint(rest, g0, g1, nodes,
           main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist);
         let (m0, m1) = pair_mul(f0, f1, g0, g1);
@@ -674,9 +674,9 @@ def verifier := ⟦
       main: List‹Ext›, main_next: List‹Ext›, prep: List‹Ext›, prep_next: List‹Ext›,
       s2: List‹Ext›, s2next: List‹Ext›, publics: List‹Ext›,
       isf: Ext, isl: Ext, ist: Ext) -> Ext {
-    match load(lks) {
-      ListNode.Nil => acc,
-      ListNode.Cons(lk, rest) =>
+    match lks {
+      List.Nil => acc,
+      List.Cons(__cell14) => let (lk, rest) = load(__cell14);
         let SysLookup.Mk(mid, args) = lk;
         let (f0, f1) = logup_fingerprint(args, g0, g1, nodes,
           main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist);
@@ -746,14 +746,14 @@ def verifier := ⟦
     -- across the domain, mirroring the Rust prover/verifier).
     let inj0 = @eg_mul(isl, @eg_mul(@eg_sub(na0, a0), [inorm, 0]));
     let inj1 = @eg_mul(isl, @eg_mul(@eg_sub(na1, a1), [inorm, 0]));
-    match load(lks) {
+    match lks {
       -- No lookups: single pass-through column, acc′ − acc + inj = 0.
-      ListNode.Nil =>
+      List.Nil =>
         let acc = ood_fold(base, alpha,
           @eg_add(@eg_sub(list_lookup(s2next, 0), list_lookup(s2, 0)), inj0));
         ood_fold(acc, alpha,
           @eg_add(@eg_sub(list_lookup(s2next, 1), list_lookup(s2, 1)), inj1)),
-      ListNode.Cons(_h, _t) =>
+      List.Cons(__cell15) => let (_h, _t) = load(__cell15);
         logup_steps_fold(base, alpha, lks, 0, list_length(lks),
           0, k, k, [1, 0], [0, 0], [0, 0], [0, 0], inj0, inj1,
           b0, b1, g0, g1, nodes,
@@ -766,11 +766,11 @@ def verifier := ⟦
   -- (`EF::from(coord)`). Indexed by the compiled `Public` node index
   -- (`num_publics = 4·D`, `D = 2`).
   fn build_publics(lch: Ext, fch: Ext, accp: Ext, naccp: Ext) -> List‹Ext› {
-    store(ListNode.Cons([lch[0], 0], store(ListNode.Cons([lch[1], 0],
-    store(ListNode.Cons([fch[0], 0], store(ListNode.Cons([fch[1], 0],
-    store(ListNode.Cons([accp[0], 0], store(ListNode.Cons([accp[1], 0],
-    store(ListNode.Cons([naccp[0], 0], store(ListNode.Cons([naccp[1], 0],
-    store(ListNode.Nil)))))))))))))))))
+    List.Cons(store(([lch[0], 0], List.Cons(store(([lch[1], 0],
+    List.Cons(store(([fch[0], 0], List.Cons(store(([fch[1], 0],
+    List.Cons(store(([accp[0], 0], List.Cons(store(([accp[1], 0],
+    List.Cons(store(([naccp[0], 0], List.Cons(store(([naccp[1], 0],
+    List.Nil))))))))))))))))))))))))
   }
 
   -- ==========================================================================
@@ -788,9 +788,9 @@ def verifier := ⟦
   -- `Σᵢ powᵢ·sliceᵢ` with `powᵢ = zeta_pow_n^i` (`pow` threads the running
   -- power, starting at 1).
   fn quotient_eval(slices: List‹Ext›, zeta_pow_n: Ext, pow: Ext) -> Ext {
-    match load(slices) {
-      ListNode.Nil => [0, 0],
-      ListNode.Cons(c, rest) =>
+    match slices {
+      List.Nil => [0, 0],
+      List.Cons(__cell16) => let (c, rest) = load(__cell16);
         @eg_add(@eg_mul(pow, c), quotient_eval(rest, zeta_pow_n, @eg_mul(pow, zeta_pow_n))),
     }
   }
@@ -813,10 +813,10 @@ def verifier := ⟦
   -- `(Nil, Nil)` if the circuit has no preprocessed trace.
   fn ood_prep_rows(prep_opt: PreprocessedOpt, oi: OptIdx) -> (List‹Ext›, List‹Ext›) {
     match oi {
-      OptIdx.NoIdx => (store(ListNode.Nil), store(ListNode.Nil)),
+      OptIdx.NoIdx => (List.Nil, List.Nil),
       OptIdx.SomeIdx(j) =>
         match prep_opt {
-          PreprocessedOpt.NoPreprocessed => (store(ListNode.Nil), store(ListNode.Nil)),
+          PreprocessedOpt.NoPreprocessed => (List.Nil, List.Nil),
           PreprocessedOpt.SomePreprocessed(round) =>
             let pr = list_lookup(round, j);
             (list_lookup(pr, 0), list_lookup(pr, 1)),
@@ -832,9 +832,9 @@ def verifier := ⟦
       stage1: OpenedRound, stage2: OpenedRound, prep_opt: PreprocessedOpt,
       q_opened: OpenedRound, i: G, accp: Ext,
       lch: Ext, fch: Ext, alpha: Ext, zeta: Ext) -> G {
-    match load(circuits) {
-      ListNode.Nil => 1,
-      ListNode.Cons(circ, rest) =>
+    match circuits {
+      List.Nil => 1,
+      List.Cons(__cell17) => let (circ, rest) = load(__cell17);
         let SysCircuit.Mk(nodes, _node_count, zeros, md, lks, k) = circ;
         let l = to_field(list_lookup(log_degrees, i));
         let qd = quotient_degree_of(md);
@@ -867,9 +867,9 @@ def verifier := ⟦
   -- The fingerprint of one claim's values: `Σ vᵢ · fch^i` (each `vᵢ` lifted from
   -- its raw u64 limb to an extension element). Mirrors `lookup::fingerprint`.
   fn fingerprint_vals(fch: Ext, vals: List‹U64›) -> Ext {
-    match load(vals) {
-      ListNode.Nil => [0, 0],
-      ListNode.Cons(v, rest) =>
+    match vals {
+      List.Nil => [0, 0],
+      List.Cons(__cell18) => let (v, rest) = load(__cell18);
         @eg_add([@gl_val(v), 0], @eg_mul(fch, fingerprint_vals(fch, rest))),
     }
   }
@@ -878,9 +878,9 @@ def verifier := ⟦
   -- `acc = Σ_claims 1 / (lookup_challenge + fingerprint(fingerprint_challenge, claim))`
   -- (Rust `verify_multiple_claims`, lines 227-232). Empty claim list → zero.
   fn claims_acc(acc: Ext, claims: List‹List‹U64››, lch: Ext, fch: Ext) -> Ext {
-    match load(claims) {
-      ListNode.Nil => acc,
-      ListNode.Cons(c, rest) =>
+    match claims {
+      List.Nil => acc,
+      List.Cons(__cell19) => let (c, rest) = load(__cell19);
         let msg = @eg_add(lch, fingerprint_vals(fch, c));
         claims_acc(@eg_add(acc, @eg_inverse(msg)), rest, lch, fch),
     }
@@ -932,34 +932,34 @@ def verifier := ⟦
 
   -- 1 iff every element of `l` is boolean (0 or 1).
   fn assert_bits(l: List‹G›) -> G {
-    match load(l) {
-      ListNode.Nil => 1,
-      ListNode.Cons(b, rest) =>
+    match l {
+      List.Nil => 1,
+      List.Cons(__cell20) => let (b, rest) = load(__cell20);
         assert_eq!(b * (b - 1), 0);
         assert_bits(rest),
     }
   }
   -- The verifying key's circuits at active positions, in order.
   fn select_active_circuits(circuits: List‹SysCircuit›, active: List‹G›) -> List‹SysCircuit› {
-    match load(circuits) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(c, crest) =>
-        let &ListNode.Cons(b, arest) = active;
+    match circuits {
+      List.Nil => List.Nil,
+      List.Cons(__cell21) => let (c, crest) = load(__cell21);
+        let List.Cons(__cell25) = active; let (b, arest) = load(__cell25);
         match b {
           0 => select_active_circuits(crest, arest),
-          _ => store(ListNode.Cons(c, select_active_circuits(crest, arest))),
+          _ => List.Cons(store((c, select_active_circuits(crest, arest)))),
         },
     }
   }
   -- The preprocessed-index entries at active positions, in order.
   fn select_active_prep(prep_indices: List‹OptIdx›, active: List‹G›) -> List‹OptIdx› {
-    match load(prep_indices) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(p, prest) =>
-        let &ListNode.Cons(b, arest) = active;
+    match prep_indices {
+      List.Nil => List.Nil,
+      List.Cons(__cell22) => let (p, prest) = load(__cell22);
+        let List.Cons(__cell26) = active; let (b, arest) = load(__cell26);
         match b {
           0 => select_active_prep(prest, arest),
-          _ => store(ListNode.Cons(p, select_active_prep(prest, arest))),
+          _ => List.Cons(store((p, select_active_prep(prest, arest)))),
         },
     }
   }
@@ -973,11 +973,11 @@ def verifier := ⟦
   }
   fn read_claims_n(stream: ByteStream, n: G) -> (List‹List‹U64››, ByteStream) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (List.Nil, stream),
       _ =>
         let (c, s) = read_one_claim(stream);
         let (rest, s2) = read_claims_n(s, n - 1);
-        (store(ListNode.Cons(c, rest)), s2),
+        (List.Cons(store((c, rest))), s2),
     }
   }
   fn read_one_claim(stream: ByteStream) -> (List‹U64›, ByteStream) {
@@ -986,11 +986,11 @@ def verifier := ⟦
   }
   fn read_claim_vals_n(stream: ByteStream, n: G) -> (List‹U64›, ByteStream) {
     match n {
-      0 => (store(ListNode.Nil), stream),
+      0 => (List.Nil, stream),
       _ =>
         let (x, s) = read_u64(stream);
         let (rest, s2) = read_claim_vals_n(s, n - 1);
-        (store(ListNode.Cons(x, rest)), s2),
+        (List.Cons(store((x, rest))), s2),
     }
   }
 ⟧
diff --git a/Tests/Aiur/Aiur.lean b/Tests/Aiur/Aiur.lean
index 5a9688d3..2f998783 100644
--- a/Tests/Aiur/Aiur.lean
+++ b/Tests/Aiur/Aiur.lean
@@ -647,35 +647,37 @@ def toplevel := ⟦
 
   ---------------------------------------------------------------------------
   -- Unconstrained big-uint div/mod: lists of [U8; 8] limbs in, the same
-  -- list datatype at [G; 8] out. The datatype must declare Cons FIRST
-  -- (runtime tag contract: 0 = Cons, 1 = Nil). Limbs are little-endian
-  -- u64s, head-first.
+  -- list datatype at [G; 8] out. The list must be the null-pointer-niche
+  -- shape { Nil, Cons(&(limb, tail)) } — one field element wide, 0 = Nil.
+  -- Limbs are little-endian u64s, head-first.
   ---------------------------------------------------------------------------
   enum BNode‹T› {
-    BCons(T, &BNode‹T›),
-    BNil
+    BNil,
+    BCons(&(T, BNode‹T›))
   }
 
-  fn blist0() -> &BNode‹[U8; 8]› { store(BNode.BNil) }
-  fn blist1(l: [U8; 8]) -> &BNode‹[U8; 8]› { store(BNode.BCons(l, blist0())) }
-  fn blist2(l0: [U8; 8], l1: [U8; 8]) -> &BNode‹[U8; 8]› {
-    store(BNode.BCons(l0, blist1(l1)))
+  fn blist0() -> BNode‹[U8; 8]› { BNode.BNil }
+  fn blist1(l: [U8; 8]) -> BNode‹[U8; 8]› { BNode.BCons(store((l, blist0()))) }
+  fn blist2(l0: [U8; 8], l1: [U8; 8]) -> BNode‹[U8; 8]› {
+    BNode.BCons(store((l0, blist1(l1))))
   }
 
   -- u64 value of the first result limb (fits in G for the cases below).
-  fn glimb_val(p: &BNode‹[G; 8]›) -> G {
-    match load(p) {
-      BNode.BCons(l, _) => l[0] + 256 * l[1] + 65536 * l[2] + 16777216 * l[3]
+  fn glimb_val(p: BNode‹[G; 8]›) -> G {
+    match p {
+      BNode.BCons(c) =>
+        let (l, _) = load(c);
+        l[0] + 256 * l[1] + 65536 * l[2] + 16777216 * l[3]
         + 4294967296 * l[4] + 1099511627776 * l[5] + 281474976710656 * l[6]
         + 72057594037927936 * l[7],
       BNode.BNil => 0,
     }
   }
 
-  fn glist_is_nil(p: &BNode‹[G; 8]›) -> G {
-    match load(p) {
+  fn glist_is_nil(p: BNode‹[G; 8]›) -> G {
+    match p {
       BNode.BNil => 1,
-      BNode.BCons(_, _) => 0,
+      BNode.BCons(_) => 0,
     }
   }
 
@@ -718,6 +720,54 @@ def toplevel := ⟦
     let s5 = c[4] + c[0];                       -- 255
     s1 + s2 + 10 * s3 + s4 + s5                 -- 1309
   }
+
+  ---------------------------------------------------------------------------
+  -- Null-pointer niche optimization: a two-constructor enum with one
+  -- nullary ctor and a pointer field in the other drops its tag slot
+  -- (pointers are 1-based, so 0 is the impossible pointer and doubles as
+  -- the nullary variant). These pin construction, both match directions,
+  -- the wildcard-covers-nullary form, non-tail (matchContinue) dispatch,
+  -- and Nil-crossing recursion on the width-1 extreme (PNat = bare ptr).
+  ---------------------------------------------------------------------------
+  enum NichePair { NEmpty, NPair(G, &(G, G)) }   -- niche slot at offset 1
+
+  fn niche_sum(p: NichePair) -> G {
+    match p {
+      NichePair.NEmpty => 100,
+      NichePair.NPair(x, q) =>
+        let (a, b) = load(q);
+        x + a + b,
+    }
+  }
+
+  pub fn niche_test(x: G) -> G {
+    let e = NichePair.NEmpty;
+    let p = NichePair.NPair(x, store((x + 1, x + 2)));
+    -- Wildcard covers the nullary ctor (compiles to case 0).
+    let w = match p {
+      NichePair.NPair(y, _) => y,
+      _ => 0,
+    };
+    -- Non-tail match: dispatches through matchContinue.
+    let v = match e {
+      NichePair.NEmpty => 3,
+      NichePair.NPair(_, _) => 4,
+    };
+    niche_sum(e) + niche_sum(p) + w + v
+  }
+
+  enum PNat { PZero, PSucc(&PNat) }   -- niche size 1: the bare pointer
+
+  fn pnat_to_g(n: PNat) -> G {
+    match n {
+      PNat.PZero => 0,
+      PNat.PSucc(m) => 1 + pnat_to_g(load(m)),
+    }
+  }
+
+  pub fn niche_nat_test() -> G {
+    pnat_to_g(PNat.PSucc(store(PNat.PSucc(store(PNat.PZero)))))
+  }
 ⟧
 
 /-- The PROVING suite: every case runs the full prove+verify pipeline
@@ -839,6 +889,10 @@ def aiurTestCases : List AiurTestCase := [
 
     -- Unconstrained g_to_bytes / g_inverse hints: all cases in one proof
     .prove `hint_test #[] #[1309],
+
+    -- Null-pointer niche: 100 + (5+6+7) + 5 + 3 = 126; PNat depth 2
+    .prove `niche_test #[5] #[126],
+    .prove `niche_nat_test #[] #[2],
   ]
 
 end
diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean
index fcb66cb3..7fe4b8e2 100644
--- a/Tests/Ix/IxVM.lean
+++ b/Tests/Ix/IxVM.lean
@@ -276,77 +276,77 @@ private def nameOfString (str : String) : Lean.Name :=
     listed constant fails the suite, so a regression cannot land quietly
     and an improvement has to be acknowledged by re-pinning. -/
 private def kernelCheckEntries : List (String × Nat) := [
-  ("HEq",                                                        129_468_104),
-  ("HEq.rec",                                                    132_906_026),
-  ("Eq.rec",                                                     132_478_828),
-  ("Nat",                                                        129_465_234),
-  ("Nat.add",                                                    165_101_768),
-  ("Nat.add_comm",                                               292_233_964),
-  ("Nat.decEq",                                                  341_688_609),
-  ("Nat.decLe",                                                  732_649_143),
-  ("Nat.sub_le_of_le_add",                                     1_793_179_373),
-  ("Nat.shiftRight_succ",                                      1_331_066_612),
-  ("Trans.mk",                                                   134_728_178),
-  ("Array.append_assoc",                                       8_622_658_358),
-  ("Vector.append",                                            8_832_851_736),
-  ("IxVMPrim.nat_add_lit",                                       205_724_339),
-  ("IxVMPrim.nat_sub_lit",                                       222_270_629),
-  ("IxVMPrim.nat_mul_lit",                                       197_332_156),
-  ("IxVMPrim.nat_mul_big",                                       195_705_843),
-  ("IxVMPrim.nat_div_lit",                                     1_300_339_885),
-  ("IxVMPrim.nat_mod_lit",                                     1_325_741_257),
-  ("IxVMPrim.nat_succ_lit",                                      143_973_320),
-  ("IxVMPrim.nat_pred_lit",                                      165_092_837),
-  ("IxVMPrim.nat_gcd_lit",                                     2_077_835_172),
-  ("IxVMPrim.nat_land_lit",                                    3_392_593_650),
-  ("IxVMPrim.nat_lor_lit",                                     3_394_992_980),
-  ("IxVMPrim.nat_xor_lit",                                     3_414_869_484),
-  ("IxVMPrim.nat_shl_lit",                                       225_040_363),
-  ("IxVMPrim.nat_shr_lit",                                     1_315_348_247),
-  ("IxVMPrim.nat_pow_big",                                       386_936_789),
-  ("IxVMPrim.nat_beq_lit",                                       195_521_462),
-  ("IxVMPrim.nat_ble_lit",                                       190_279_372),
-  ("IxVMPrim.nat_cases_big",                                     164_636_470),
-  ("IxVMPrim.nat_dec_le",                                        750_956_369),
-  ("IxVMPrim.nat_dec_lt",                                        762_189_408),
-  ("IxVMPrim.nat_dec_eq",                                        380_458_982),
-  ("IxVMPrim.str_size_lit",                                    2_388_927_980),
-  ("IxVMPrim.bv_to_nat_lit",                                   1_978_174_861),
-  ("IxVMInd.Even",                                               199_959_069),
-  ("IxVMInd.Odd",                                                199_961_684),
-  ("IxVMInd.Even.rec",                                           217_262_251),
-  ("IxVMInd.Odd.rec",                                            217_263_174),
-  ("IxVMInd.Tree",                                               130_857_345),
-  ("IxVMInd.Tree.rec",                                           139_889_786),
-  ("IxVMInd.DedupM",                                             134_173_839),
-  ("IxVMInd.DedupM.rec",                                         146_300_644),
-  ("IxVMInd.DepthM",                                             132_567_341),
-  ("IxVMInd.DepthM.rec",                                         142_699_828),
-  ("String.Internal.append",                                   2_360_689_108),
-  ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_499_089_916),
-  ("Lean.Syntax.rec",                                          2_415_335_613),
-  ("IxVMInd.AuxTie",                                             315_165_566),
-  ("IxVMInd.AuxTie.rec",                                         353_876_276),
-  ("IxVMInd.HiddenIdx",                                          130_050_254),
-  ("IxVMInd.HiddenIdx.rec",                                      132_543_931),
-  ("IxVMInd.thmMajorUse",                                        488_836_722),
-  ("IxVMInd.partialKRec",                                        149_911_108),
-  ("IxVMInd.deepRebase",                                         208_423_967),
-  ("String.Slice.Pattern.Model.NoPrefixForwardPatternModel.rec", 3_305_647_446),
-  ("Lean.Widget.TaggedText.rec",                               2_384_562_452),
-  ("Lean.Doc.Part.rec",                                        2_425_540_913),
-  ("Lean.Doc.Block.rec",                                       2_582_167_982),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 132_244_429),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 135_209_335),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 134_204_496),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 134_204_496),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 134_204_496),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 132_442_751),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 142_670_108),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 142_669_322),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 134_204_496),
-  ("strOfListFoldSize",                                        2_677_189_647),
-  ("strOfListFoldSizeAscii",                                   2_678_115_796),
+  ("HEq",                                                        129_452_033),
+  ("HEq.rec",                                                    132_869_091),
+  ("Eq.rec",                                                     132_442_994),
+  ("Nat",                                                        129_450_277),
+  ("Nat.add",                                                    164_890_337),
+  ("Nat.add_comm",                                               291_623_068),
+  ("Nat.decEq",                                                  341_027_323),
+  ("Nat.decLe",                                                  731_419_451),
+  ("Nat.sub_le_of_le_add",                                     1_791_330_465),
+  ("Nat.shiftRight_succ",                                      1_329_614_126),
+  ("Trans.mk",                                                   134_634_976),
+  ("Array.append_assoc",                                       8_615_024_879),
+  ("Vector.append",                                            8_825_255_303),
+  ("IxVMPrim.nat_add_lit",                                       205_332_645),
+  ("IxVMPrim.nat_sub_lit",                                       221_842_951),
+  ("IxVMPrim.nat_mul_lit",                                       197_012_773),
+  ("IxVMPrim.nat_mul_big",                                       195_386_038),
+  ("IxVMPrim.nat_div_lit",                                     1_298_915_781),
+  ("IxVMPrim.nat_mod_lit",                                     1_324_305_019),
+  ("IxVMPrim.nat_succ_lit",                                      143_867_256),
+  ("IxVMPrim.nat_pred_lit",                                      164_902_648),
+  ("IxVMPrim.nat_gcd_lit",                                     2_075_950_107),
+  ("IxVMPrim.nat_land_lit",                                    3_390_218_317),
+  ("IxVMPrim.nat_lor_lit",                                     3_392_599_555),
+  ("IxVMPrim.nat_xor_lit",                                     3_412_495_908),
+  ("IxVMPrim.nat_shl_lit",                                       224_618_426),
+  ("IxVMPrim.nat_shr_lit",                                     1_313_925_087),
+  ("IxVMPrim.nat_pow_big",                                       385_639_869),
+  ("IxVMPrim.nat_beq_lit",                                       195_194_350),
+  ("IxVMPrim.nat_ble_lit",                                       189_954_357),
+  ("IxVMPrim.nat_cases_big",                                     164_440_920),
+  ("IxVMPrim.nat_dec_le",                                        749_750_305),
+  ("IxVMPrim.nat_dec_lt",                                        760_946_663),
+  ("IxVMPrim.nat_dec_eq",                                        379_697_845),
+  ("IxVMPrim.str_size_lit",                                    2_386_586_561),
+  ("IxVMPrim.bv_to_nat_lit",                                   1_976_297_367),
+  ("IxVMInd.Even",                                               199_575_115),
+  ("IxVMInd.Odd",                                                199_584_074),
+  ("IxVMInd.Even.rec",                                           216_840_351),
+  ("IxVMInd.Odd.rec",                                            216_838_654),
+  ("IxVMInd.Tree",                                               130_828_990),
+  ("IxVMInd.Tree.rec",                                           139_815_000),
+  ("IxVMInd.DedupM",                                             134_128_004),
+  ("IxVMInd.DedupM.rec",                                         146_211_533),
+  ("IxVMInd.DepthM",                                             132_531_376),
+  ("IxVMInd.DepthM.rec",                                         142_619_248),
+  ("String.Internal.append",                                   2_358_310_010),
+  ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_496_197_377),
+  ("Lean.Syntax.rec",                                          2_412_908_694),
+  ("IxVMInd.AuxTie",                                             314_499_208),
+  ("IxVMInd.AuxTie.rec",                                         353_113_454),
+  ("IxVMInd.HiddenIdx",                                          130_031_808),
+  ("IxVMInd.HiddenIdx.rec",                                      132_509_166),
+  ("IxVMInd.thmMajorUse",                                        487_992_755),
+  ("IxVMInd.partialKRec",                                        149_784_340),
+  ("IxVMInd.deepRebase",                                         208_030_352),
+  ("String.Slice.Pattern.Model.NoPrefixForwardPatternModel.rec", 3_302_270_505),
+  ("Lean.Widget.TaggedText.rec",                               2_382_222_714),
+  ("Lean.Doc.Part.rec",                                        2_423_011_673),
+  ("Lean.Doc.Block.rec",                                       2_579_686_056),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 132_207_345),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 135_154_086),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 134_159_091),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 134_159_091),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 134_159_091),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 132_403_942),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 142_583_998),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 142_581_620),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 134_159_091),
+  ("strOfListFoldSize",                                        2_674_852_406),
+  ("strOfListFoldSizeAscii",                                   2_675_774_968),
 ]
 
 /-- Variant of `kernelChecks`, pinned to the baseline
diff --git a/Tests/Main.lean b/Tests/Main.lean
index 736f6595..b5586c93 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -223,8 +223,8 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [
             let actual :=
               (Aiur.computeStats v2Env.compiled qc v2Env.shapes).totalFftCost.round.toUInt64.toNat
             pure (LSpec.test
-              s!"Shard pipeline FFT matches: expected 7332697739, got {actual}"
-              (actual = 7_332_697_739))
+              s!"Shard pipeline FFT matches: expected 7327924669, got {actual}"
+              (actual = 7_327_924_669))
       LSpec.lspecIO
         (.ofList [("ixvm",
           [fullSeq, aiurSeq, arenaSeq, exploitSeq, paritySeq, shardSeq])]) []),
diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs
index 69e03e12..ca062910 100644
--- a/crates/aiur/src/execute.rs
+++ b/crates/aiur/src/execute.rs
@@ -345,7 +345,10 @@ impl Function {
             }
             map.extend_from_slice(result.output);
           } else {
-            let ptr = G::from_usize(memory_queries.len());
+            // Pointers are 1-based: 0 is reserved as the impossible (null)
+            // pointer, which the memory circuit enforces by pinning the
+            // first row's pointer to 1 (see `memory.rs`).
+            let ptr = G::from_usize(memory_queries.len() + 1);
             memory_queries.insert(
               &values,
               &[ptr],
@@ -364,8 +367,10 @@ impl Function {
           let ptr_usize = usize::try_from(ptr_u64)
             .ok()
             .ok_or(ExecError::PointerTooLarge(ptr_u64))?;
-          let (args, multiplicity) = memory_queries
-            .get_index_mut(ptr_usize)
+          // 1-based pointers: 0 is the reserved null pointer and never binds.
+          let (args, multiplicity) = ptr_usize
+            .checked_sub(1)
+            .and_then(|i| memory_queries.get_index_mut(i))
             .ok_or(ExecError::UnboundPointer { ptr: ptr_u64, size: *size })?;
           if !unconstrained {
             *multiplicity += G::ONE;
@@ -566,19 +571,19 @@ impl Function {
         },
         ExecEntry::Op(Op::UnconstrainedBigUintDivMod(a_idx, b_idx)) => {
           // Unconstrained hint for klimbs-style LE byte division. Inputs are
-          // pointers to `List<U64>` (in memory[10]) values storing `a` and
-          // `b` as little-endian u64 limbs (each limb's 8 bytes are stored
-          // tag-then-bytes within memory[10] per the standard Aiur enum
-          // layout: `[tag, b0..b7, next_ptr]`). The op walks both lists,
-          // computes `q = a / b` and `r = a % b` via `num_bigint::BigUint`,
-          // and rebuilds the result lists in memory[10] with multiplicity 0
-          // (unconstrained). Returns the two new head pointers. The caller
-          // is responsible for verifying `q * b + r == a` and `r < b` in
-          // constrained code.
+          // pointers to `List<U64>` (in memory[9]) values storing `a` and
+          // `b` as little-endian u64 limbs. `List<U64>` is null-pointer-
+          // niche optimized: no tag slot, layout `[b0..b7, next_ptr]`,
+          // Nil = the all-zero vector (pointer slot 0 is impossible).
+          // The op walks both lists, computes `q = a / b` and `r = a % b`
+          // via `num_bigint::BigUint`, and rebuilds the result lists in
+          // memory[9] with multiplicity 0 (unconstrained). Returns the two
+          // new head pointers. The caller is responsible for verifying
+          // `q * b + r == a` and `r < b` in constrained code.
           //
-          // The `memory[10]` channel is chosen because the standard Aiur
-          // layout for a tagged enum with a `(U64, &Self)` constructor is
-          // `tag(1) + U64(8) + ptr(1) = 10` G values.
+          // The `memory[9]` channel is chosen because the niche layout of
+          // an enum with a `(U64, &Self)` constructor is
+          // `U64(8) + ptr(1) = 9` G values.
           let a_ptr = map[*a_idx];
           let b_ptr = map[*b_idx];
           let a_limbs = read_klimbs_u64(&record.memory_queries, a_ptr)
@@ -885,7 +890,7 @@ pub fn unconstrained_big_uint_div_mod_helper(
 
 /// Read-only twin of `unconstrained_big_uint_div_mod_helper` for trace
 /// population: recompute `(q, r)` and resolve the list-head pointers the
-/// execution already recorded in `memory[10]` — every node was built there
+/// execution already recorded in `memory[9]` — every node was built there
 /// during execution, so each key must be present.
 pub fn find_unconstrained_big_uint_div_mod(
   a_ptr: G,
@@ -912,22 +917,17 @@ fn find_klimbs_u64(
   memory: &FxIndexMap<usize, QueryMap>,
   limbs: &[u64],
 ) -> Result<G, String> {
-  let queries = memory.get(&10).ok_or_else(|| {
-    "memory[10] channel not registered (no List<U64> in program?)".to_string()
+  let queries = memory.get(&9).ok_or_else(|| {
+    "memory[9] channel not registered (no List<U64> in program?)".to_string()
   })?;
-  let nil_key: Vec<G> =
-    std::iter::once(G::ONE).chain((0..9).map(|_| G::ZERO)).collect();
-  let mut tail_ptr = queries
-    .get(&nil_key)
-    .ok_or_else(|| "List<U64> Nil node not recorded".to_string())?
-    .output[0];
+  // Nil is the LITERAL 0 list value: no node is stored for it.
+  let mut tail_ptr = G::ZERO;
   for limb in limbs.iter().rev() {
-    let mut key: Vec<G> = Vec::with_capacity(10);
-    key.push(G::ZERO); // Cons tag (first variant of ListNode‹U64›)
+    let mut key: Vec<G> = Vec::with_capacity(9);
     for b in &limb.to_le_bytes() {
       key.push(G::from_u8(*b));
     }
-    key.push(tail_ptr);
+    key.push(tail_ptr); // niche slot: a real pointer, never 0
     tail_ptr = queries
       .get(&key)
       .ok_or_else(|| {
@@ -938,47 +938,44 @@ fn find_klimbs_u64(
   Ok(tail_ptr)
 }
 
-/// Walk a `List<U64>` chain from `head_ptr` in `memory[10]`, returning the
-/// u64 limbs in head-first order. Each memory[10] entry is the standard Aiur
-/// tagged-enum layout: `[tag, byte0..byte7, next_ptr]`. `tag == 0` = Nil
-/// (terminator), `tag == 1` = Cons. Bytes are LE within the u64.
+/// Walk a `List<U64>` chain from `head_ptr` in `memory[9]`, returning the
+/// u64 limbs in head-first order. `List<U64>` is the null-pointer-niche
+/// enum `{ Nil, Cons(&(U64, List<U64>)) }`: the list VALUE is one field
+/// element — 0 is Nil, anything else points at a `(limb, tail)` cell in
+/// memory[9] laid out `[byte0..byte7, tail]`. Bytes are LE within the u64.
 fn read_klimbs_u64(
   memory: &FxIndexMap<usize, QueryMap>,
   head_ptr: G,
 ) -> Result<Vec<u64>, String> {
-  let queries = memory.get(&10).ok_or_else(|| {
-    "memory[10] channel not registered (no List<U64> in program?)".to_string()
+  let queries = memory.get(&9).ok_or_else(|| {
+    "memory[9] channel not registered (no List<U64> in program?)".to_string()
   })?;
   let mut limbs: Vec<u64> = Vec::new();
   let mut ptr = head_ptr;
   loop {
     let ptr_u64 = ptr.as_canonical_u64();
-    let ptr_idx = usize::try_from(ptr_u64)
-      .map_err(|_e| format!("ptr {ptr_u64} too large for usize"))?;
-    let (key, _) = queries.get_index(ptr_idx).ok_or_else(|| {
-      format!("unbound ptr {ptr_u64} in memory[10] (walking List<U64>)")
-    })?;
-    let tag = key[0].as_canonical_u64();
-    // `enum ListNode { Cons, Nil }` in Ix/IxVM/Core.lean — Cons is the
-    // first variant (tag 0), Nil the second (tag 1).
-    if tag == 1 {
+    // The LIST VALUE is the niche discriminant: 0 IS Nil (no node exists),
+    // anything else is a pointer to the `(limb, tail)` cell.
+    if ptr_u64 == 0 {
       return Ok(limbs);
     }
-    if tag != 0 {
-      return Err(format!(
-        "List<U64> walk: unexpected tag {tag} (expected 0=Cons, 1=Nil)"
-      ));
-    }
+    let ptr_idx = usize::try_from(ptr_u64)
+      .map_err(|_e| format!("ptr {ptr_u64} too large for usize"))?;
+    // 1-based pointers: 0 is the reserved null pointer.
+    let (key, _) =
+      ptr_idx.checked_sub(1).and_then(|i| queries.get_index(i)).ok_or_else(
+        || format!("unbound ptr {ptr_u64} in memory[9] (walking List<U64>)"),
+      )?;
     let mut limb_bytes = [0u8; 8];
     for k in 0..8 {
-      let b = key[1 + k].as_canonical_u64();
+      let b = key[k].as_canonical_u64();
       if b >= 256 {
         return Err(format!("limb byte {b} out of u8 range"));
       }
       limb_bytes[k] = u8::try_from(b).expect("range-checked above");
     }
     limbs.push(u64::from_le_bytes(limb_bytes));
-    ptr = key[9];
+    ptr = key[8];
   }
 }
 
@@ -1015,7 +1012,7 @@ fn biguint_to_klimbs_u64(n: &num_bigint::BigUint) -> Vec<u64> {
     .collect()
 }
 
-/// Build a `List<U64>` chain in `memory[10]` from `limbs` (head-first order)
+/// Build a `List<U64>` chain in `memory[9]` from `limbs` (head-first order)
 /// and return the head pointer. Each entry is inserted with multiplicity 0
 /// (unconstrained); subsequent constrained `Load`s by the kernel will bump
 /// the multiplicity. Content-addressed via `QueryMap::get_mut`, so repeated
@@ -1024,32 +1021,23 @@ fn build_klimbs_u64(
   memory: &mut FxIndexMap<usize, QueryMap>,
   limbs: &[u64],
 ) -> Result<G, String> {
-  let queries = memory.get_mut(&10).ok_or_else(|| {
-    "memory[10] channel not registered (no List<U64> in program?)".to_string()
+  let queries = memory.get_mut(&9).ok_or_else(|| {
+    "memory[9] channel not registered (no List<U64> in program?)".to_string()
   })?;
-  // Find or insert the Nil ptr (tag = 1, padded payload all zero).
-  let nil_key: Vec<G> =
-    std::iter::once(G::ONE).chain((0..9).map(|_| G::ZERO)).collect();
-  let mut tail_ptr = if let Some(out) = queries.get_mut(&nil_key) {
-    out.output[0]
-  } else {
-    let ptr = G::from_usize(queries.len());
-    queries.insert(&nil_key, &[ptr], G::ZERO);
-    ptr
-  };
+  // Nil is the LITERAL 0 list value: no node is stored for it.
+  let mut tail_ptr = G::ZERO;
   // Walk limbs in REVERSE so each Cons points at the previously-built tail.
   for limb in limbs.iter().rev() {
     let bytes = limb.to_le_bytes();
-    let mut key: Vec<G> = Vec::with_capacity(10);
-    key.push(G::ZERO); // Cons tag (first variant of ListNode‹U64›)
+    let mut key: Vec<G> = Vec::with_capacity(9);
     for b in &bytes {
       key.push(G::from_u8(*b));
     }
-    key.push(tail_ptr);
+    key.push(tail_ptr); // niche slot: a real pointer, never 0
     tail_ptr = if let Some(out) = queries.get_mut(&key) {
       out.output[0]
     } else {
-      let ptr = G::from_usize(queries.len());
+      let ptr = G::from_usize(queries.len() + 1);
       queries.insert(&key, &[ptr], G::ZERO);
       ptr
     };
diff --git a/crates/aiur/src/memory.rs b/crates/aiur/src/memory.rs
index c3fd487d..26a48337 100644
--- a/crates/aiur/src/memory.rs
+++ b/crates/aiur/src/memory.rs
@@ -49,8 +49,13 @@ impl Memory {
     let lookups = vec![Lookup { multiplicity: -multiplicity, args }];
 
     // Transition constraints (formerly the `Air::eval` body): the selector is
-    // boolean; a real next row implies a real current row; and the pointer
-    // increments by one across a real transition.
+    // boolean; a real next row implies a real current row; the pointer
+    // increments by one across a real transition; and the FIRST row's
+    // pointer is pinned to 1. Pointers are therefore exactly 1..height on
+    // real rows, which reserves 0 as the impossible (null) pointer — the
+    // niche the compiler's null-pointer optimization relies on. (Real rows
+    // are a prefix, so when the trace is nonempty row 0 is real; an
+    // unqueried table has an empty trace and is deactivated.)
     let is_real = Expr::main(1);
     let is_real_next = Expr::main_next(1);
     let ptr = Expr::main(2);
@@ -59,8 +64,9 @@ impl Memory {
     let is_real_transition = is_real_next * Expr::IsTransition;
     let constraints = vec![
       is_real.clone() * (is_real.clone() - one()),
-      is_real_transition.clone() * (is_real - one()),
-      is_real_transition * (ptr + one() - ptr_next),
+      is_real_transition.clone() * (is_real.clone() - one()),
+      is_real_transition * (ptr.clone() + one() - ptr_next),
+      Expr::IsFirstRow * is_real * (ptr - one()),
     ];
 
     (Self { width }, constraints, lookups)
@@ -98,7 +104,7 @@ impl Memory {
         let (values, result) = queries.get_index(i).expect("index in range");
         row[0] = result.multiplicity;
         row[1] = G::ONE;
-        row[2] = G::from_usize(i);
+        row[2] = G::from_usize(i + 1);
         row[3..].copy_from_slice(values);
 
         let args = Self::lookup_args(G::from_usize(size), row[2], &row[3..]);
diff --git a/crates/aiur/src/trace.rs b/crates/aiur/src/trace.rs
index fe107ab1..1583cd73 100644
--- a/crates/aiur/src/trace.rs
+++ b/crates/aiur/src/trace.rs
@@ -347,8 +347,9 @@ impl Op {
           .get(&size)
           .expect("Invalid memory size");
         let values = values.iter().map(|a| map[*a].0).collect::<Vec<_>>();
+        // 1-based pointers (0 is the reserved null pointer).
         let ptr = G::from_usize(
-          memory_queries.get_index_of(&values).expect("Unbound pointer"),
+          memory_queries.get_index_of(&values).expect("Unbound pointer") + 1,
         );
         map.push((ptr, 1));
         slice.push_auxiliary(index, ptr);
@@ -364,8 +365,11 @@ impl Op {
         let (ptr, _) = map[*ptr];
         let ptr_u64 = ptr.as_canonical_u64();
         let ptr_usize = usize::try_from(ptr_u64).expect("Pointer is too big");
-        let (values, _) =
-          memory_queries.get_index(ptr_usize).expect("Unbound pointer");
+        // 1-based pointers (0 is the reserved null pointer).
+        let (values, _) = ptr_usize
+          .checked_sub(1)
+          .and_then(|i| memory_queries.get_index(i))
+          .expect("Unbound pointer");
         for f in values.iter() {
           map.push((*f, 1));
           slice.push_auxiliary(index, *f);
@@ -583,7 +587,7 @@ impl Op {
       Op::UnconstrainedBigUintDivMod(a, b) => {
         // Mirrors the execute arm and the two auxiliary columns the
         // constraints allocate: recompute `(q, r)` and resolve the head
-        // pointers execution recorded in memory[10]. Skipping the two map
+        // pointers execution recorded in memory[9]. Skipping the two map
         // pushes would shift every later `ValIdx` (and witness column) in
         // the block.
         let (q_ptr, r_ptr) = find_unconstrained_big_uint_div_mod(
diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs
index a6d1277f..04bb7b92 100644
--- a/crates/ixvm-codegen/src/aiur_ixvm.rs
+++ b/crates/ixvm-codegen/src/aiur_ixvm.rs
@@ -28,7 +28,7 @@ fn aiur_fn_0(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -61,7 +61,7 @@ fn aiur_fn_0(
     let __v_31: G = __loaded[29];
     let __v_32: G = __loaded[30];
     let __v_33: G = __loaded[31];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_34: G = __loaded[0];
     let __v_35: G = __loaded[1];
     let __v_36: G = __loaded[2];
@@ -324,7 +324,7 @@ fn aiur_fn_1(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -357,7 +357,7 @@ fn aiur_fn_1(
     let __v_31: G = __loaded[29];
     let __v_32: G = __loaded[30];
     let __v_33: G = __loaded[31];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_34: G = __loaded[0];
     let __v_35: G = __loaded[1];
     let __v_36: G = __loaded[2];
@@ -424,10 +424,8 @@ fn aiur_fn_2(
     let __v_2: G = inp[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_2] = [__v_5];
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_2] = [__v_3];
         record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -440,9 +438,8 @@ fn aiur_fn_2(
         let __v_7: G = __r_arr[0];
         let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr };
         let __v_8: G = __io_read[0];
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_2] = [__v_10];
+        let __v_9: G = { let __values: [G; 2] = [__v_8, __v_7]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_2] = [__v_9];
         record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -2615,9 +2612,9 @@ fn aiur_fn_16(
     let __v_30: G = G::from_u64(205);
     let __v_31: G = G::from_u64(224);
     let __v_32: G = G::from_u64(91);
-    let __v_33: G = G::from_u64(1);
-    let __v_34: G = G::from_u64(1);
-    let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_33: G = G::from_u64(0);
+    let __v_34: G = G::from_u64(0);
+    let __v_35: G = G::from_u64(0);
     let __v_36: G = G::from_u64(0);
     let __v_37: G = G::from_u64(0);
     let __v_38: G = G::from_u64(0);
@@ -2626,84 +2623,45 @@ fn aiur_fn_16(
     let __v_41: G = G::from_u64(0);
     let __v_42: G = G::from_u64(0);
     let __v_43: G = G::from_u64(0);
-    let __v_44: G = G::from_u64(0);
-    let __v_45: G = G::from_u64(0);
-    let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_48: G = G::from_u64(1);
-    let __v_49: G = G::from_u64(1);
-    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
-    let __v_51: G = __r_arr[0];
-    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-    let __v_52: G = __loaded[0];
-    let __v_53: G = __loaded[1];
-    let __v_54: G = __loaded[2];
-    let __v_55: G = __loaded[3];
-    let __v_56: G = __loaded[4];
-    let __v_57: G = __loaded[5];
-    let __v_58: G = __loaded[6];
-    let __v_59: G = __loaded[7];
-    let __v_60: G = __loaded[8];
-    let __v_61: G = __loaded[9];
-    let __v_62: G = __loaded[10];
-    let __v_63: G = __loaded[11];
-    let __v_64: G = __loaded[12];
-    let __v_65: G = __loaded[13];
-    let __v_66: G = __loaded[14];
-    let __v_67: G = __loaded[15];
-    let __v_68: G = __loaded[16];
-    let __v_69: G = __loaded[17];
-    let __v_70: G = __loaded[18];
-    let __v_71: G = __loaded[19];
-    let __v_72: G = __loaded[20];
-    let __v_73: G = __loaded[21];
-    let __v_74: G = __loaded[22];
-    let __v_75: G = __loaded[23];
-    let __v_76: G = __loaded[24];
-    let __v_77: G = __loaded[25];
-    let __v_78: G = __loaded[26];
-    let __v_79: G = __loaded[27];
-    let __v_80: G = __loaded[28];
-    let __v_81: G = __loaded[29];
-    let __v_82: G = __loaded[30];
-    let __v_83: G = __loaded[31];
-    let __v_84: G = __loaded[32];
-    let __v_85: G = __loaded[33];
-    let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } };
-    let __v_86: G = __r_arr[0];
-    let __v_87: G = __r_arr[1];
-    let __v_88: G = __r_arr[2];
-    let __v_89: G = __r_arr[3];
-    let __v_90: G = __r_arr[4];
-    let __v_91: G = __r_arr[5];
-    let __v_92: G = __r_arr[6];
-    let __v_93: G = __r_arr[7];
-    let __v_94: G = __r_arr[8];
-    let __v_95: G = __r_arr[9];
-    let __v_96: G = __r_arr[10];
-    let __v_97: G = __r_arr[11];
-    let __v_98: G = __r_arr[12];
-    let __v_99: G = __r_arr[13];
-    let __v_100: G = __r_arr[14];
-    let __v_101: G = __r_arr[15];
-    let __v_102: G = __r_arr[16];
-    let __v_103: G = __r_arr[17];
-    let __v_104: G = __r_arr[18];
-    let __v_105: G = __r_arr[19];
-    let __v_106: G = __r_arr[20];
-    let __v_107: G = __r_arr[21];
-    let __v_108: G = __r_arr[22];
-    let __v_109: G = __r_arr[23];
-    let __v_110: G = __r_arr[24];
-    let __v_111: G = __r_arr[25];
-    let __v_112: G = __r_arr[26];
-    let __v_113: G = __r_arr[27];
-    let __v_114: G = __r_arr[28];
-    let __v_115: G = __r_arr[29];
-    let __v_116: G = __r_arr[30];
-    let __v_117: G = __r_arr[31];
-    let __ret: [G; OUT_16] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117];
+    let __v_44: G = { let __values: [G; 8] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_45: 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_46: G = G::from_u64(0);
+    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_33, __v_34, __v_35, __v_44, __v_45, __v_46]; 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_47: G = __r_arr[0];
+    let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_47]; 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_48: G = __r_arr[0];
+    let __v_49: G = __r_arr[1];
+    let __v_50: G = __r_arr[2];
+    let __v_51: G = __r_arr[3];
+    let __v_52: G = __r_arr[4];
+    let __v_53: G = __r_arr[5];
+    let __v_54: G = __r_arr[6];
+    let __v_55: G = __r_arr[7];
+    let __v_56: G = __r_arr[8];
+    let __v_57: G = __r_arr[9];
+    let __v_58: G = __r_arr[10];
+    let __v_59: G = __r_arr[11];
+    let __v_60: G = __r_arr[12];
+    let __v_61: G = __r_arr[13];
+    let __v_62: G = __r_arr[14];
+    let __v_63: G = __r_arr[15];
+    let __v_64: G = __r_arr[16];
+    let __v_65: G = __r_arr[17];
+    let __v_66: G = __r_arr[18];
+    let __v_67: G = __r_arr[19];
+    let __v_68: G = __r_arr[20];
+    let __v_69: G = __r_arr[21];
+    let __v_70: G = __r_arr[22];
+    let __v_71: G = __r_arr[23];
+    let __v_72: G = __r_arr[24];
+    let __v_73: G = __r_arr[25];
+    let __v_74: G = __r_arr[26];
+    let __v_75: G = __r_arr[27];
+    let __v_76: G = __r_arr[28];
+    let __v_77: G = __r_arr[29];
+    let __v_78: G = __r_arr[30];
+    let __v_79: G = __r_arr[31];
+    let __ret: [G; OUT_16] = [__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];
     record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -2931,16 +2889,16 @@ fn aiur_fn_18(
     let __v_30: G = __r_arr[29];
     let __v_31: G = __r_arr[30];
     let __v_32: G = __r_arr[31];
-    let __v_33: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_18] = [__v_33];
     record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_19: usize = 67;
-const IN_19: usize = 67;
-const OUT_19: usize = 67;
+const INPUT_SIZE_19: usize = 34;
+const IN_19: usize = 34;
+const OUT_19: usize = 34;
 fn aiur_fn_19(
   inp: [G; IN_19],
   record: &mut QueryRecord,
@@ -2982,361 +2940,16 @@ fn aiur_fn_19(
     let __v_31: G = inp[31];
     let __v_32: G = inp[32];
     let __v_33: G = inp[33];
-    let __v_34: G = inp[34];
-    let __v_35: G = inp[35];
-    let __v_36: G = inp[36];
-    let __v_37: G = inp[37];
-    let __v_38: G = inp[38];
-    let __v_39: G = inp[39];
-    let __v_40: G = inp[40];
-    let __v_41: G = inp[41];
-    let __v_42: G = inp[42];
-    let __v_43: G = inp[43];
-    let __v_44: G = inp[44];
-    let __v_45: G = inp[45];
-    let __v_46: G = inp[46];
-    let __v_47: G = inp[47];
-    let __v_48: G = inp[48];
-    let __v_49: G = inp[49];
-    let __v_50: G = inp[50];
-    let __v_51: G = inp[51];
-    let __v_52: G = inp[52];
-    let __v_53: G = inp[53];
-    let __v_54: G = inp[54];
-    let __v_55: G = inp[55];
-    let __v_56: G = inp[56];
-    let __v_57: G = inp[57];
-    let __v_58: G = inp[58];
-    let __v_59: G = inp[59];
-    let __v_60: G = inp[60];
-    let __v_61: G = inp[61];
-    let __v_62: G = inp[62];
-    let __v_63: G = inp[63];
-    let __v_64: G = inp[64];
-    let __v_65: G = inp[65];
-    let __v_66: G = inp[66];
     match __v_0.as_canonical_u64() {
-      1u64 => {
-        let __v_67: G = G::from_u64(1);
-        let __v_68: G = G::from_u64(1);
-        let __v_69: G = G::from_u64(1);
-        let __ret: [G; OUT_19] = [__v_67, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_68, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69];
+      0u64 => {
+        let __v_34: G = G::from_u64(1);
+        let __v_35: G = G::from_u64(0);
+        let __ret: [G; OUT_19] = [__v_34, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_35];
         record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-        let __v_67: G = __loaded[0];
-        let __v_68: G = __loaded[1];
-        let __v_69: G = __loaded[2];
-        let __v_70: G = __loaded[3];
-        let __v_71: G = __loaded[4];
-        let __v_72: G = __loaded[5];
-        let __v_73: G = __loaded[6];
-        let __v_74: G = __loaded[7];
-        let __v_75: G = __loaded[8];
-        let __v_76: G = __loaded[9];
-        let __v_77: G = __loaded[10];
-        let __v_78: G = __loaded[11];
-        let __v_79: G = __loaded[12];
-        let __v_80: G = __loaded[13];
-        let __v_81: G = __loaded[14];
-        let __v_82: G = __loaded[15];
-        let __v_83: G = __loaded[16];
-        let __v_84: G = __loaded[17];
-        let __v_85: G = __loaded[18];
-        let __v_86: G = __loaded[19];
-        let __v_87: G = __loaded[20];
-        let __v_88: G = __loaded[21];
-        let __v_89: G = __loaded[22];
-        let __v_90: G = __loaded[23];
-        let __v_91: G = __loaded[24];
-        let __v_92: G = __loaded[25];
-        let __v_93: G = __loaded[26];
-        let __v_94: G = __loaded[27];
-        let __v_95: G = __loaded[28];
-        let __v_96: G = __loaded[29];
-        let __v_97: G = __loaded[30];
-        let __v_98: G = __loaded[31];
-        let __v_99: G = __loaded[32];
-        let __v_100: G = __loaded[33];
-        let __v_101: G = G::from_u64(0);
-        let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
-        let __v_102: G = __r_arr[0];
-        let __v_103: G = __r_arr[1];
-        let __v_104: G = __r_arr[2];
-        let __v_105: G = __r_arr[3];
-        let __v_106: G = __r_arr[4];
-        let __v_107: G = __r_arr[5];
-        let __v_108: G = __r_arr[6];
-        let __v_109: G = __r_arr[7];
-        let __v_110: G = __r_arr[8];
-        let __v_111: G = __r_arr[9];
-        let __v_112: G = __r_arr[10];
-        let __v_113: G = __r_arr[11];
-        let __v_114: G = __r_arr[12];
-        let __v_115: G = __r_arr[13];
-        let __v_116: G = __r_arr[14];
-        let __v_117: G = __r_arr[15];
-        let __v_118: G = __r_arr[16];
-        let __v_119: G = __r_arr[17];
-        let __v_120: G = __r_arr[18];
-        let __v_121: G = __r_arr[19];
-        let __v_122: G = __r_arr[20];
-        let __v_123: G = __r_arr[21];
-        let __v_124: G = __r_arr[22];
-        let __v_125: G = __r_arr[23];
-        let __v_126: G = __r_arr[24];
-        let __v_127: G = __r_arr[25];
-        let __v_128: G = __r_arr[26];
-        let __v_129: G = __r_arr[27];
-        let __v_130: G = __r_arr[28];
-        let __v_131: G = __r_arr[29];
-        let __v_132: G = __r_arr[30];
-        let __v_133: G = __r_arr[31];
-        let __v_134: G = __r_arr[32];
-        let __v_135: G = __r_arr[33];
-        let __v_136: G = __r_arr[34];
-        let __v_137: G = __r_arr[35];
-        let __v_138: G = __r_arr[36];
-        let __v_139: G = __r_arr[37];
-        let __v_140: G = __r_arr[38];
-        let __v_141: G = __r_arr[39];
-        let __v_142: G = __r_arr[40];
-        let __v_143: G = __r_arr[41];
-        let __v_144: G = __r_arr[42];
-        let __v_145: G = __r_arr[43];
-        let __v_146: G = __r_arr[44];
-        let __v_147: G = __r_arr[45];
-        let __v_148: G = __r_arr[46];
-        let __v_149: G = __r_arr[47];
-        let __v_150: G = __r_arr[48];
-        let __v_151: G = __r_arr[49];
-        let __v_152: G = __r_arr[50];
-        let __v_153: G = __r_arr[51];
-        let __v_154: G = __r_arr[52];
-        let __v_155: G = __r_arr[53];
-        let __v_156: G = __r_arr[54];
-        let __v_157: G = __r_arr[55];
-        let __v_158: G = __r_arr[56];
-        let __v_159: G = __r_arr[57];
-        let __v_160: G = __r_arr[58];
-        let __v_161: G = __r_arr[59];
-        let __v_162: G = __r_arr[60];
-        let __v_163: G = __r_arr[61];
-        let __v_164: G = __r_arr[62];
-        let __v_165: G = __r_arr[63];
-        let __v_166: G = __r_arr[64];
-        let __v_167: G = __r_arr[65];
-        let __v_168: G = __r_arr[66];
-        match __v_102.as_canonical_u64() {
-          0u64 => {
-            let __v_169: G = G::from_u64(1);
-            let __ret: [G; OUT_19] = [__v_169, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168];
-            record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_169: G = G::from_u64(4);
-            let __v_170: G = G::from_u64(8);
-            let __v_171: G = G::from_u64(103);
-            let __v_172: G = G::from_u64(230);
-            let __v_173: G = G::from_u64(9);
-            let __v_174: G = G::from_u64(106);
-            let __v_175: G = G::from_u64(133);
-            let __v_176: G = G::from_u64(174);
-            let __v_177: G = G::from_u64(103);
-            let __v_178: G = G::from_u64(187);
-            let __v_179: G = G::from_u64(114);
-            let __v_180: G = G::from_u64(243);
-            let __v_181: G = G::from_u64(110);
-            let __v_182: G = G::from_u64(60);
-            let __v_183: G = G::from_u64(58);
-            let __v_184: G = G::from_u64(245);
-            let __v_185: G = G::from_u64(79);
-            let __v_186: G = G::from_u64(165);
-            let __v_187: G = G::from_u64(127);
-            let __v_188: G = G::from_u64(82);
-            let __v_189: G = G::from_u64(14);
-            let __v_190: G = G::from_u64(81);
-            let __v_191: G = G::from_u64(140);
-            let __v_192: G = G::from_u64(104);
-            let __v_193: G = G::from_u64(5);
-            let __v_194: G = G::from_u64(155);
-            let __v_195: G = G::from_u64(171);
-            let __v_196: G = G::from_u64(217);
-            let __v_197: G = G::from_u64(131);
-            let __v_198: G = G::from_u64(31);
-            let __v_199: G = G::from_u64(25);
-            let __v_200: G = G::from_u64(205);
-            let __v_201: G = G::from_u64(224);
-            let __v_202: G = G::from_u64(91);
-            match __v_135.as_canonical_u64() {
-              1u64 => {
-                let __v_203: G = (__v_170 * __v_66);
-                let __v_204: G = (__v_169 + __v_203);
-                let __v_205: G = G::from_u64(0);
-                let __v_206: G = G::from_u64(0);
-                let __v_207: G = G::from_u64(0);
-                let __v_208: G = G::from_u64(0);
-                let __v_209: G = G::from_u64(0);
-                let __v_210: G = G::from_u64(0);
-                let __v_211: G = G::from_u64(0);
-                let __v_212: G = G::from_u64(0);
-                let __v_213: G = G::from_u64(64);
-                let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_204]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
-                let __v_214: G = __r_arr[0];
-                let __v_215: G = __r_arr[1];
-                let __v_216: G = __r_arr[2];
-                let __v_217: G = __r_arr[3];
-                let __v_218: G = __r_arr[4];
-                let __v_219: G = __r_arr[5];
-                let __v_220: G = __r_arr[6];
-                let __v_221: G = __r_arr[7];
-                let __v_222: G = __r_arr[8];
-                let __v_223: G = __r_arr[9];
-                let __v_224: G = __r_arr[10];
-                let __v_225: G = __r_arr[11];
-                let __v_226: G = __r_arr[12];
-                let __v_227: G = __r_arr[13];
-                let __v_228: G = __r_arr[14];
-                let __v_229: G = __r_arr[15];
-                let __v_230: G = __r_arr[16];
-                let __v_231: G = __r_arr[17];
-                let __v_232: G = __r_arr[18];
-                let __v_233: G = __r_arr[19];
-                let __v_234: G = __r_arr[20];
-                let __v_235: G = __r_arr[21];
-                let __v_236: G = __r_arr[22];
-                let __v_237: G = __r_arr[23];
-                let __v_238: G = __r_arr[24];
-                let __v_239: G = __r_arr[25];
-                let __v_240: G = __r_arr[26];
-                let __v_241: G = __r_arr[27];
-                let __v_242: G = __r_arr[28];
-                let __v_243: G = __r_arr[29];
-                let __v_244: G = __r_arr[30];
-                let __v_245: G = __r_arr[31];
-                let __v_246: G = G::from_u64(0);
-                let __v_247: G = G::from_u64(0);
-                let __v_248: G = G::from_u64(0);
-                let __v_249: G = { let __values: [G; 34] = [__v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_19] = [__v_246, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_248, __v_249, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245];
-                record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_203: G = G::from_u64(0);
-                let __v_204: G = G::from_u64(0);
-                let __v_205: G = G::from_u64(0);
-                let __v_206: G = G::from_u64(0);
-                let __v_207: G = G::from_u64(0);
-                let __v_208: G = G::from_u64(0);
-                let __v_209: G = G::from_u64(0);
-                let __v_210: G = G::from_u64(0);
-                let __v_211: G = G::from_u64(64);
-                let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_169]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
-                let __v_212: G = __r_arr[0];
-                let __v_213: G = __r_arr[1];
-                let __v_214: G = __r_arr[2];
-                let __v_215: G = __r_arr[3];
-                let __v_216: G = __r_arr[4];
-                let __v_217: G = __r_arr[5];
-                let __v_218: G = __r_arr[6];
-                let __v_219: G = __r_arr[7];
-                let __v_220: G = __r_arr[8];
-                let __v_221: G = __r_arr[9];
-                let __v_222: G = __r_arr[10];
-                let __v_223: G = __r_arr[11];
-                let __v_224: G = __r_arr[12];
-                let __v_225: G = __r_arr[13];
-                let __v_226: G = __r_arr[14];
-                let __v_227: G = __r_arr[15];
-                let __v_228: G = __r_arr[16];
-                let __v_229: G = __r_arr[17];
-                let __v_230: G = __r_arr[18];
-                let __v_231: G = __r_arr[19];
-                let __v_232: G = __r_arr[20];
-                let __v_233: G = __r_arr[21];
-                let __v_234: G = __r_arr[22];
-                let __v_235: G = __r_arr[23];
-                let __v_236: G = __r_arr[24];
-                let __v_237: G = __r_arr[25];
-                let __v_238: G = __r_arr[26];
-                let __v_239: G = __r_arr[27];
-                let __v_240: G = __r_arr[28];
-                let __v_241: G = __r_arr[29];
-                let __v_242: G = __r_arr[30];
-                let __v_243: G = __r_arr[31];
-                let __v_244: G = G::from_u64(0);
-                let __v_245: G = G::from_u64(0);
-                let __v_246: G = G::from_u64(0);
-                let __v_247: G = { let __values: [G; 34] = [__v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_19] = [__v_244, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_246, __v_247, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243];
-                record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_102.as_canonical_u64()));
-          },
-        }
-      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_20: usize = 34;
-const IN_20: usize = 34;
-const OUT_20: usize = 32;
-fn aiur_fn_20(
-  inp: [G; IN_20],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_20], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    let __v_31: G = inp[31];
-    let __v_32: G = inp[32];
-    let __v_33: G = inp[33];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+        let __loaded: [G; 33] = { let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 33 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 33] = __args[..33].try_into().unwrap(); __arr };
         let __v_34: G = __loaded[0];
         let __v_35: G = __loaded[1];
         let __v_36: G = __loaded[2];
@@ -3370,207 +2983,383 @@ fn aiur_fn_20(
         let __v_64: G = __loaded[30];
         let __v_65: G = __loaded[31];
         let __v_66: G = __loaded[32];
-        let __v_67: G = __loaded[33];
-        match __v_34.as_canonical_u64() {
+        let __v_67: G = G::from_u64(0);
+        let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
+        let __v_68: G = __r_arr[0];
+        let __v_69: G = __r_arr[1];
+        let __v_70: G = __r_arr[2];
+        let __v_71: G = __r_arr[3];
+        let __v_72: G = __r_arr[4];
+        let __v_73: G = __r_arr[5];
+        let __v_74: G = __r_arr[6];
+        let __v_75: G = __r_arr[7];
+        let __v_76: G = __r_arr[8];
+        let __v_77: G = __r_arr[9];
+        let __v_78: G = __r_arr[10];
+        let __v_79: G = __r_arr[11];
+        let __v_80: G = __r_arr[12];
+        let __v_81: G = __r_arr[13];
+        let __v_82: G = __r_arr[14];
+        let __v_83: G = __r_arr[15];
+        let __v_84: G = __r_arr[16];
+        let __v_85: G = __r_arr[17];
+        let __v_86: G = __r_arr[18];
+        let __v_87: G = __r_arr[19];
+        let __v_88: G = __r_arr[20];
+        let __v_89: G = __r_arr[21];
+        let __v_90: G = __r_arr[22];
+        let __v_91: G = __r_arr[23];
+        let __v_92: G = __r_arr[24];
+        let __v_93: G = __r_arr[25];
+        let __v_94: G = __r_arr[26];
+        let __v_95: G = __r_arr[27];
+        let __v_96: G = __r_arr[28];
+        let __v_97: G = __r_arr[29];
+        let __v_98: G = __r_arr[30];
+        let __v_99: G = __r_arr[31];
+        let __v_100: G = __r_arr[32];
+        let __v_101: G = __r_arr[33];
+        match __v_68.as_canonical_u64() {
+          0u64 => {
+            let __v_102: G = G::from_u64(1);
+            let __ret: [G; OUT_19] = [__v_102, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_101];
+            record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
           1u64 => {
+            let __v_102: G = G::from_u64(4);
+            let __v_103: G = G::from_u64(8);
+            let __v_104: G = G::from_u64(103);
+            let __v_105: G = G::from_u64(230);
+            let __v_106: G = G::from_u64(9);
+            let __v_107: G = G::from_u64(106);
+            let __v_108: G = G::from_u64(133);
+            let __v_109: G = G::from_u64(174);
+            let __v_110: G = G::from_u64(103);
+            let __v_111: G = G::from_u64(187);
+            let __v_112: G = G::from_u64(114);
+            let __v_113: G = G::from_u64(243);
+            let __v_114: G = G::from_u64(110);
+            let __v_115: G = G::from_u64(60);
+            let __v_116: G = G::from_u64(58);
+            let __v_117: G = G::from_u64(245);
+            let __v_118: G = G::from_u64(79);
+            let __v_119: G = G::from_u64(165);
+            let __v_120: G = G::from_u64(127);
+            let __v_121: G = G::from_u64(82);
+            let __v_122: G = G::from_u64(14);
+            let __v_123: G = G::from_u64(81);
+            let __v_124: G = G::from_u64(140);
+            let __v_125: G = G::from_u64(104);
+            let __v_126: G = G::from_u64(5);
+            let __v_127: G = G::from_u64(155);
+            let __v_128: G = G::from_u64(171);
+            let __v_129: G = G::from_u64(217);
+            let __v_130: G = G::from_u64(131);
+            let __v_131: G = G::from_u64(31);
+            let __v_132: G = G::from_u64(25);
+            let __v_133: G = G::from_u64(205);
+            let __v_134: G = G::from_u64(224);
+            let __v_135: G = G::from_u64(91);
+            match __v_101.as_canonical_u64() {
+              0u64 => {
+                let __v_136: G = (__v_103 * __v_33);
+                let __v_137: G = (__v_102 + __v_136);
+                let __v_138: G = G::from_u64(0);
+                let __v_139: G = G::from_u64(0);
+                let __v_140: G = G::from_u64(0);
+                let __v_141: G = G::from_u64(0);
+                let __v_142: G = G::from_u64(0);
+                let __v_143: G = G::from_u64(0);
+                let __v_144: G = G::from_u64(0);
+                let __v_145: G = G::from_u64(0);
+                let __v_146: G = G::from_u64(64);
+                let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__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, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_137]; 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_147: G = __r_arr[0];
+                let __v_148: G = __r_arr[1];
+                let __v_149: G = __r_arr[2];
+                let __v_150: G = __r_arr[3];
+                let __v_151: G = __r_arr[4];
+                let __v_152: G = __r_arr[5];
+                let __v_153: G = __r_arr[6];
+                let __v_154: G = __r_arr[7];
+                let __v_155: G = __r_arr[8];
+                let __v_156: G = __r_arr[9];
+                let __v_157: G = __r_arr[10];
+                let __v_158: G = __r_arr[11];
+                let __v_159: G = __r_arr[12];
+                let __v_160: G = __r_arr[13];
+                let __v_161: G = __r_arr[14];
+                let __v_162: G = __r_arr[15];
+                let __v_163: G = __r_arr[16];
+                let __v_164: G = __r_arr[17];
+                let __v_165: G = __r_arr[18];
+                let __v_166: G = __r_arr[19];
+                let __v_167: G = __r_arr[20];
+                let __v_168: G = __r_arr[21];
+                let __v_169: G = __r_arr[22];
+                let __v_170: G = __r_arr[23];
+                let __v_171: G = __r_arr[24];
+                let __v_172: G = __r_arr[25];
+                let __v_173: G = __r_arr[26];
+                let __v_174: G = __r_arr[27];
+                let __v_175: G = __r_arr[28];
+                let __v_176: G = __r_arr[29];
+                let __v_177: G = __r_arr[30];
+                let __v_178: G = __r_arr[31];
+                let __v_179: G = G::from_u64(0);
+                let __v_180: G = G::from_u64(0);
+                let __v_181: G = { let __values: [G; 33] = [__v_101, __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]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_19] = [__v_179, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_181];
+                record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_136: G = G::from_u64(0);
+                let __v_137: G = G::from_u64(0);
+                let __v_138: G = G::from_u64(0);
+                let __v_139: G = G::from_u64(0);
+                let __v_140: G = G::from_u64(0);
+                let __v_141: G = G::from_u64(0);
+                let __v_142: G = G::from_u64(0);
+                let __v_143: G = G::from_u64(0);
+                let __v_144: G = G::from_u64(64);
+                let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__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, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_102]; 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_145: G = __r_arr[0];
+                let __v_146: G = __r_arr[1];
+                let __v_147: G = __r_arr[2];
+                let __v_148: G = __r_arr[3];
+                let __v_149: G = __r_arr[4];
+                let __v_150: G = __r_arr[5];
+                let __v_151: G = __r_arr[6];
+                let __v_152: G = __r_arr[7];
+                let __v_153: G = __r_arr[8];
+                let __v_154: G = __r_arr[9];
+                let __v_155: G = __r_arr[10];
+                let __v_156: G = __r_arr[11];
+                let __v_157: G = __r_arr[12];
+                let __v_158: G = __r_arr[13];
+                let __v_159: G = __r_arr[14];
+                let __v_160: G = __r_arr[15];
+                let __v_161: G = __r_arr[16];
+                let __v_162: G = __r_arr[17];
+                let __v_163: G = __r_arr[18];
+                let __v_164: G = __r_arr[19];
+                let __v_165: G = __r_arr[20];
+                let __v_166: G = __r_arr[21];
+                let __v_167: G = __r_arr[22];
+                let __v_168: G = __r_arr[23];
+                let __v_169: G = __r_arr[24];
+                let __v_170: G = __r_arr[25];
+                let __v_171: G = __r_arr[26];
+                let __v_172: G = __r_arr[27];
+                let __v_173: G = __r_arr[28];
+                let __v_174: G = __r_arr[29];
+                let __v_175: G = __r_arr[30];
+                let __v_176: G = __r_arr[31];
+                let __v_177: G = G::from_u64(0);
+                let __v_178: G = G::from_u64(0);
+                let __v_179: G = { let __values: [G; 33] = [__v_101, __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]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_19] = [__v_177, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_179];
+                record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_68.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_20: usize = 1;
+const IN_20: usize = 1;
+const OUT_20: usize = 32;
+fn aiur_fn_20(
+  inp: [G; IN_20],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_20], 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(1);
+        if (__v_1 != __v_2) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_20] = [__v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1];
+        record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 33] = { let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 33 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 33] = __args[..33].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __v_10: G = __loaded[9];
+        let __v_11: G = __loaded[10];
+        let __v_12: G = __loaded[11];
+        let __v_13: G = __loaded[12];
+        let __v_14: G = __loaded[13];
+        let __v_15: G = __loaded[14];
+        let __v_16: G = __loaded[15];
+        let __v_17: G = __loaded[16];
+        let __v_18: G = __loaded[17];
+        let __v_19: G = __loaded[18];
+        let __v_20: G = __loaded[19];
+        let __v_21: G = __loaded[20];
+        let __v_22: G = __loaded[21];
+        let __v_23: G = __loaded[22];
+        let __v_24: G = __loaded[23];
+        let __v_25: G = __loaded[24];
+        let __v_26: G = __loaded[25];
+        let __v_27: G = __loaded[26];
+        let __v_28: G = __loaded[27];
+        let __v_29: G = __loaded[28];
+        let __v_30: G = __loaded[29];
+        let __v_31: G = __loaded[30];
+        let __v_32: G = __loaded[31];
+        let __v_33: G = __loaded[32];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
             let __ret: [G; OUT_20] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
             record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-            let __v_68: G = __loaded[0];
-            let __v_69: G = __loaded[1];
-            let __v_70: G = __loaded[2];
-            let __v_71: G = __loaded[3];
-            let __v_72: G = __loaded[4];
-            let __v_73: G = __loaded[5];
-            let __v_74: G = __loaded[6];
-            let __v_75: G = __loaded[7];
-            let __v_76: G = __loaded[8];
-            let __v_77: G = __loaded[9];
-            let __v_78: G = __loaded[10];
-            let __v_79: G = __loaded[11];
-            let __v_80: G = __loaded[12];
-            let __v_81: G = __loaded[13];
-            let __v_82: G = __loaded[14];
-            let __v_83: G = __loaded[15];
-            let __v_84: G = __loaded[16];
-            let __v_85: G = __loaded[17];
-            let __v_86: G = __loaded[18];
-            let __v_87: G = __loaded[19];
-            let __v_88: G = __loaded[20];
-            let __v_89: G = __loaded[21];
-            let __v_90: G = __loaded[22];
-            let __v_91: G = __loaded[23];
-            let __v_92: G = __loaded[24];
-            let __v_93: G = __loaded[25];
-            let __v_94: G = __loaded[26];
-            let __v_95: G = __loaded[27];
-            let __v_96: G = __loaded[28];
-            let __v_97: G = __loaded[29];
-            let __v_98: G = __loaded[30];
-            let __v_99: G = __loaded[31];
-            let __v_100: G = __loaded[32];
-            let __v_101: G = __loaded[33];
-            let __v_102: G = G::from_u64(1);
-            let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
-            let __v_103: G = __r_arr[0];
-            let __v_104: G = __r_arr[1];
-            let __v_105: G = __r_arr[2];
-            let __v_106: G = __r_arr[3];
-            let __v_107: G = __r_arr[4];
-            let __v_108: G = __r_arr[5];
-            let __v_109: G = __r_arr[6];
-            let __v_110: G = __r_arr[7];
-            let __v_111: G = __r_arr[8];
-            let __v_112: G = __r_arr[9];
-            let __v_113: G = __r_arr[10];
-            let __v_114: G = __r_arr[11];
-            let __v_115: G = __r_arr[12];
-            let __v_116: G = __r_arr[13];
-            let __v_117: G = __r_arr[14];
-            let __v_118: G = __r_arr[15];
-            let __v_119: G = __r_arr[16];
-            let __v_120: G = __r_arr[17];
-            let __v_121: G = __r_arr[18];
-            let __v_122: G = __r_arr[19];
-            let __v_123: G = __r_arr[20];
-            let __v_124: G = __r_arr[21];
-            let __v_125: G = __r_arr[22];
-            let __v_126: G = __r_arr[23];
-            let __v_127: G = __r_arr[24];
-            let __v_128: G = __r_arr[25];
-            let __v_129: G = __r_arr[26];
-            let __v_130: G = __r_arr[27];
-            let __v_131: G = __r_arr[28];
-            let __v_132: G = __r_arr[29];
-            let __v_133: G = __r_arr[30];
-            let __v_134: G = __r_arr[31];
-            let __v_135: G = __r_arr[32];
-            let __v_136: G = __r_arr[33];
-            let __v_137: G = __r_arr[34];
-            let __v_138: G = __r_arr[35];
-            let __v_139: G = __r_arr[36];
-            let __v_140: G = __r_arr[37];
-            let __v_141: G = __r_arr[38];
-            let __v_142: G = __r_arr[39];
-            let __v_143: G = __r_arr[40];
-            let __v_144: G = __r_arr[41];
-            let __v_145: G = __r_arr[42];
-            let __v_146: G = __r_arr[43];
-            let __v_147: G = __r_arr[44];
-            let __v_148: G = __r_arr[45];
-            let __v_149: G = __r_arr[46];
-            let __v_150: G = __r_arr[47];
-            let __v_151: G = __r_arr[48];
-            let __v_152: G = __r_arr[49];
-            let __v_153: G = __r_arr[50];
-            let __v_154: G = __r_arr[51];
-            let __v_155: G = __r_arr[52];
-            let __v_156: G = __r_arr[53];
-            let __v_157: G = __r_arr[54];
-            let __v_158: G = __r_arr[55];
-            let __v_159: G = __r_arr[56];
-            let __v_160: G = __r_arr[57];
-            let __v_161: G = __r_arr[58];
-            let __v_162: G = __r_arr[59];
-            let __v_163: G = __r_arr[60];
-            let __v_164: G = __r_arr[61];
-            let __v_165: G = __r_arr[62];
-            let __v_166: G = __r_arr[63];
-            let __v_167: G = __r_arr[64];
-            let __v_168: G = __r_arr[65];
-            let __v_169: G = __r_arr[66];
-            match __v_103.as_canonical_u64() {
+            let __v_34: G = G::from_u64(1);
+            let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __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 __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
+            let __v_35: G = __r_arr[0];
+            let __v_36: G = __r_arr[1];
+            let __v_37: G = __r_arr[2];
+            let __v_38: G = __r_arr[3];
+            let __v_39: G = __r_arr[4];
+            let __v_40: G = __r_arr[5];
+            let __v_41: G = __r_arr[6];
+            let __v_42: G = __r_arr[7];
+            let __v_43: G = __r_arr[8];
+            let __v_44: G = __r_arr[9];
+            let __v_45: G = __r_arr[10];
+            let __v_46: G = __r_arr[11];
+            let __v_47: G = __r_arr[12];
+            let __v_48: G = __r_arr[13];
+            let __v_49: G = __r_arr[14];
+            let __v_50: G = __r_arr[15];
+            let __v_51: G = __r_arr[16];
+            let __v_52: G = __r_arr[17];
+            let __v_53: G = __r_arr[18];
+            let __v_54: G = __r_arr[19];
+            let __v_55: G = __r_arr[20];
+            let __v_56: G = __r_arr[21];
+            let __v_57: G = __r_arr[22];
+            let __v_58: G = __r_arr[23];
+            let __v_59: G = __r_arr[24];
+            let __v_60: G = __r_arr[25];
+            let __v_61: G = __r_arr[26];
+            let __v_62: G = __r_arr[27];
+            let __v_63: G = __r_arr[28];
+            let __v_64: G = __r_arr[29];
+            let __v_65: G = __r_arr[30];
+            let __v_66: G = __r_arr[31];
+            let __v_67: G = __r_arr[32];
+            let __v_68: G = __r_arr[33];
+            match __v_35.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } };
-                let __v_170: G = __r_arr[0];
-                let __v_171: G = __r_arr[1];
-                let __v_172: G = __r_arr[2];
-                let __v_173: G = __r_arr[3];
-                let __v_174: G = __r_arr[4];
-                let __v_175: G = __r_arr[5];
-                let __v_176: G = __r_arr[6];
-                let __v_177: G = __r_arr[7];
-                let __v_178: G = __r_arr[8];
-                let __v_179: G = __r_arr[9];
-                let __v_180: G = __r_arr[10];
-                let __v_181: G = __r_arr[11];
-                let __v_182: G = __r_arr[12];
-                let __v_183: G = __r_arr[13];
-                let __v_184: G = __r_arr[14];
-                let __v_185: G = __r_arr[15];
-                let __v_186: G = __r_arr[16];
-                let __v_187: G = __r_arr[17];
-                let __v_188: G = __r_arr[18];
-                let __v_189: G = __r_arr[19];
-                let __v_190: G = __r_arr[20];
-                let __v_191: G = __r_arr[21];
-                let __v_192: G = __r_arr[22];
-                let __v_193: G = __r_arr[23];
-                let __v_194: G = __r_arr[24];
-                let __v_195: G = __r_arr[25];
-                let __v_196: G = __r_arr[26];
-                let __v_197: G = __r_arr[27];
-                let __v_198: G = __r_arr[28];
-                let __v_199: G = __r_arr[29];
-                let __v_200: G = __r_arr[30];
-                let __v_201: G = __r_arr[31];
-                let __ret: [G; OUT_20] = [__v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201];
+                let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_68]; 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_69: G = __r_arr[0];
+                let __v_70: G = __r_arr[1];
+                let __v_71: G = __r_arr[2];
+                let __v_72: G = __r_arr[3];
+                let __v_73: G = __r_arr[4];
+                let __v_74: G = __r_arr[5];
+                let __v_75: G = __r_arr[6];
+                let __v_76: G = __r_arr[7];
+                let __v_77: G = __r_arr[8];
+                let __v_78: G = __r_arr[9];
+                let __v_79: G = __r_arr[10];
+                let __v_80: G = __r_arr[11];
+                let __v_81: G = __r_arr[12];
+                let __v_82: G = __r_arr[13];
+                let __v_83: G = __r_arr[14];
+                let __v_84: G = __r_arr[15];
+                let __v_85: G = __r_arr[16];
+                let __v_86: G = __r_arr[17];
+                let __v_87: G = __r_arr[18];
+                let __v_88: G = __r_arr[19];
+                let __v_89: G = __r_arr[20];
+                let __v_90: G = __r_arr[21];
+                let __v_91: G = __r_arr[22];
+                let __v_92: G = __r_arr[23];
+                let __v_93: G = __r_arr[24];
+                let __v_94: G = __r_arr[25];
+                let __v_95: G = __r_arr[26];
+                let __v_96: G = __r_arr[27];
+                let __v_97: G = __r_arr[28];
+                let __v_98: G = __r_arr[29];
+                let __v_99: G = __r_arr[30];
+                let __v_100: G = __r_arr[31];
+                let __ret: [G; OUT_20] = [__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];
                 record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __v_170: G = G::from_u64(0);
-                let __v_171: G = { let __values: [G; 34] = [__v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_170, __v_171, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } };
-                let __v_172: G = __r_arr[0];
-                let __v_173: G = __r_arr[1];
-                let __v_174: G = __r_arr[2];
-                let __v_175: G = __r_arr[3];
-                let __v_176: G = __r_arr[4];
-                let __v_177: G = __r_arr[5];
-                let __v_178: G = __r_arr[6];
-                let __v_179: G = __r_arr[7];
-                let __v_180: G = __r_arr[8];
-                let __v_181: G = __r_arr[9];
-                let __v_182: G = __r_arr[10];
-                let __v_183: G = __r_arr[11];
-                let __v_184: G = __r_arr[12];
-                let __v_185: G = __r_arr[13];
-                let __v_186: G = __r_arr[14];
-                let __v_187: G = __r_arr[15];
-                let __v_188: G = __r_arr[16];
-                let __v_189: G = __r_arr[17];
-                let __v_190: G = __r_arr[18];
-                let __v_191: G = __r_arr[19];
-                let __v_192: G = __r_arr[20];
-                let __v_193: G = __r_arr[21];
-                let __v_194: G = __r_arr[22];
-                let __v_195: G = __r_arr[23];
-                let __v_196: G = __r_arr[24];
-                let __v_197: G = __r_arr[25];
-                let __v_198: G = __r_arr[26];
-                let __v_199: G = __r_arr[27];
-                let __v_200: G = __r_arr[28];
-                let __v_201: G = __r_arr[29];
-                let __v_202: G = __r_arr[30];
-                let __v_203: G = __r_arr[31];
-                let __ret: [G; OUT_20] = [__v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203];
+                let __v_69: G = { let __values: [G; 33] = [__v_68, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_69]; 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_70: G = __r_arr[0];
+                let __v_71: G = __r_arr[1];
+                let __v_72: G = __r_arr[2];
+                let __v_73: G = __r_arr[3];
+                let __v_74: G = __r_arr[4];
+                let __v_75: G = __r_arr[5];
+                let __v_76: G = __r_arr[6];
+                let __v_77: G = __r_arr[7];
+                let __v_78: G = __r_arr[8];
+                let __v_79: G = __r_arr[9];
+                let __v_80: G = __r_arr[10];
+                let __v_81: G = __r_arr[11];
+                let __v_82: G = __r_arr[12];
+                let __v_83: G = __r_arr[13];
+                let __v_84: G = __r_arr[14];
+                let __v_85: G = __r_arr[15];
+                let __v_86: G = __r_arr[16];
+                let __v_87: G = __r_arr[17];
+                let __v_88: G = __r_arr[18];
+                let __v_89: G = __r_arr[19];
+                let __v_90: G = __r_arr[20];
+                let __v_91: G = __r_arr[21];
+                let __v_92: G = __r_arr[22];
+                let __v_93: G = __r_arr[23];
+                let __v_94: G = __r_arr[24];
+                let __v_95: G = __r_arr[25];
+                let __v_96: G = __r_arr[26];
+                let __v_97: G = __r_arr[27];
+                let __v_98: G = __r_arr[28];
+                let __v_99: G = __r_arr[29];
+                let __v_100: G = __r_arr[30];
+                let __v_101: G = __r_arr[31];
+                let __ret: [G; OUT_20] = [__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];
                 record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_35.as_canonical_u64()));
               },
             }
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
     }
   })
 }
@@ -3592,45 +3381,40 @@ fn aiur_fn_21(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_7: G = __loaded[0];
-    let __v_8: G = __loaded[1];
-    let __v_9: G = __loaded[2];
-    match __v_7.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_21] = [__v_10];
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_21] = [__v_7];
         record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = { let __values: [G; 2] = [__v_7, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         match __v_2.as_canonical_u64() {
           63u64 => {
-            let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_21] = [__v_12];
+            let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_8, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __ret: [G; OUT_21] = [__v_10];
             record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
+            let __v_10: G = G::from_u64(1);
+            let __v_11: G = (__v_2 + __v_10);
             let __v_12: G = G::from_u64(1);
-            let __v_13: G = (__v_2 + __v_12);
-            let __v_14: G = G::from_u64(1);
-            let __v_15: G = (__v_3 + __v_14);
-            let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __ret: [G; OUT_21] = [__v_16];
+            let __v_13: G = (__v_3 + __v_12);
+            let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_8, __v_9, __v_11, __v_13, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+            let __v_14: G = __r_arr[0];
+            let __ret: [G; OUT_21] = [__v_14];
             record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-      },
     }
   })
 }
@@ -3646,712 +3430,1096 @@ fn aiur_fn_22(
 ) -> Result<[G; OUT_22], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_4: G = __loaded[0];
-        let __v_5: G = __loaded[1];
-        let __v_6: G = __loaded[2];
-        match __v_4.as_canonical_u64() {
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(1);
+        if (__v_1 != __v_2) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_22] = [__v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1];
+        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        match __v_2.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_7: G = __loaded[0];
-            let __v_8: G = __loaded[1];
-            let __v_9: G = __loaded[2];
-            match __v_7.as_canonical_u64() {
+            let __v_3: G = G::from_u64(0);
+            let __v_4: G = G::from_u64(1);
+            if (__v_3 != __v_4) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_22] = [__v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3];
+            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_3: G = __loaded[0];
+            let __v_4: G = __loaded[1];
+            match __v_4.as_canonical_u64() {
               0u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                let __v_10: G = __loaded[0];
-                let __v_11: G = __loaded[1];
-                let __v_12: G = __loaded[2];
-                match __v_10.as_canonical_u64() {
+                let __v_5: G = G::from_u64(0);
+                let __v_6: G = G::from_u64(1);
+                if (__v_5 != __v_6) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                }
+                let __ret: [G; OUT_22] = [__v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5];
+                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                let __v_5: G = __loaded[0];
+                let __v_6: G = __loaded[1];
+                match __v_6.as_canonical_u64() {
                   0u64 => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                    let __v_13: G = __loaded[0];
-                    let __v_14: G = __loaded[1];
-                    let __v_15: G = __loaded[2];
-                    match __v_13.as_canonical_u64() {
+                    let __v_7: G = G::from_u64(0);
+                    let __v_8: G = G::from_u64(1);
+                    if (__v_7 != __v_8) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                    }
+                    let __ret: [G; OUT_22] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7];
+                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                    let __v_7: G = __loaded[0];
+                    let __v_8: G = __loaded[1];
+                    match __v_8.as_canonical_u64() {
                       0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                        let __v_16: G = __loaded[0];
-                        let __v_17: G = __loaded[1];
-                        let __v_18: G = __loaded[2];
-                        match __v_16.as_canonical_u64() {
+                        let __v_9: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                        }
+                        let __ret: [G; OUT_22] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9];
+                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                        let __v_9: G = __loaded[0];
+                        let __v_10: G = __loaded[1];
+                        match __v_10.as_canonical_u64() {
                           0u64 => {
-                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                            let __v_19: G = __loaded[0];
-                            let __v_20: G = __loaded[1];
-                            let __v_21: G = __loaded[2];
-                            match __v_19.as_canonical_u64() {
+                            let __v_11: G = G::from_u64(0);
+                            let __v_12: G = G::from_u64(1);
+                            if (__v_11 != __v_12) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                            }
+                            let __ret: [G; OUT_22] = [__v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11];
+                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                            let __v_11: G = __loaded[0];
+                            let __v_12: G = __loaded[1];
+                            match __v_12.as_canonical_u64() {
                               0u64 => {
-                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                let __v_22: G = __loaded[0];
-                                let __v_23: G = __loaded[1];
-                                let __v_24: G = __loaded[2];
-                                match __v_22.as_canonical_u64() {
+                                let __v_13: G = G::from_u64(0);
+                                let __v_14: G = G::from_u64(1);
+                                if (__v_13 != __v_14) {
+                                  return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                }
+                                let __ret: [G; OUT_22] = [__v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13];
+                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                let __v_13: G = __loaded[0];
+                                let __v_14: G = __loaded[1];
+                                match __v_14.as_canonical_u64() {
                                   0u64 => {
-                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                    let __v_25: G = __loaded[0];
-                                    let __v_26: G = __loaded[1];
-                                    let __v_27: G = __loaded[2];
-                                    match __v_25.as_canonical_u64() {
+                                    let __v_15: G = G::from_u64(0);
+                                    let __v_16: G = G::from_u64(1);
+                                    if (__v_15 != __v_16) {
+                                      return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                    }
+                                    let __ret: [G; OUT_22] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15];
+                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                    let __v_15: G = __loaded[0];
+                                    let __v_16: G = __loaded[1];
+                                    match __v_16.as_canonical_u64() {
                                       0u64 => {
-                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                        let __v_28: G = __loaded[0];
-                                        let __v_29: G = __loaded[1];
-                                        let __v_30: G = __loaded[2];
-                                        match __v_28.as_canonical_u64() {
+                                        let __v_17: G = G::from_u64(0);
+                                        let __v_18: G = G::from_u64(1);
+                                        if (__v_17 != __v_18) {
+                                          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                        }
+                                        let __ret: [G; OUT_22] = [__v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
+                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                        let __v_17: G = __loaded[0];
+                                        let __v_18: G = __loaded[1];
+                                        match __v_18.as_canonical_u64() {
                                           0u64 => {
-                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                            let __v_31: G = __loaded[0];
-                                            let __v_32: G = __loaded[1];
-                                            let __v_33: G = __loaded[2];
-                                            match __v_31.as_canonical_u64() {
+                                            let __v_19: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                            }
+                                            let __ret: [G; OUT_22] = [__v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19];
+                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            return Ok(__ret);
+                                          },
+                                          _ => {
+                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                            let __v_19: G = __loaded[0];
+                                            let __v_20: G = __loaded[1];
+                                            match __v_20.as_canonical_u64() {
                                               0u64 => {
-                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                let __v_34: G = __loaded[0];
-                                                let __v_35: G = __loaded[1];
-                                                let __v_36: G = __loaded[2];
-                                                match __v_34.as_canonical_u64() {
+                                                let __v_21: G = G::from_u64(0);
+                                                let __v_22: G = G::from_u64(1);
+                                                if (__v_21 != __v_22) {
+                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                }
+                                                let __ret: [G; OUT_22] = [__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_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_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
+                                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                return Ok(__ret);
+                                              },
+                                              _ => {
+                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                let __v_21: G = __loaded[0];
+                                                let __v_22: G = __loaded[1];
+                                                match __v_22.as_canonical_u64() {
                                                   0u64 => {
-                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                    let __v_37: G = __loaded[0];
-                                                    let __v_38: G = __loaded[1];
-                                                    let __v_39: G = __loaded[2];
-                                                    match __v_37.as_canonical_u64() {
+                                                    let __v_23: G = G::from_u64(0);
+                                                    let __v_24: G = G::from_u64(1);
+                                                    if (__v_23 != __v_24) {
+                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                    }
+                                                    let __ret: [G; OUT_22] = [__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, __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, __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, __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, __v_23, __v_23, __v_23, __v_23];
+                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    return Ok(__ret);
+                                                  },
+                                                  _ => {
+                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                    let __v_23: G = __loaded[0];
+                                                    let __v_24: G = __loaded[1];
+                                                    match __v_24.as_canonical_u64() {
                                                       0u64 => {
-                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                        let __v_40: G = __loaded[0];
-                                                        let __v_41: G = __loaded[1];
-                                                        let __v_42: G = __loaded[2];
-                                                        match __v_40.as_canonical_u64() {
+                                                        let __v_25: G = G::from_u64(0);
+                                                        let __v_26: G = G::from_u64(1);
+                                                        if (__v_25 != __v_26) {
+                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                        }
+                                                        let __ret: [G; OUT_22] = [__v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25];
+                                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                        return Ok(__ret);
+                                                      },
+                                                      _ => {
+                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                        let __v_25: G = __loaded[0];
+                                                        let __v_26: G = __loaded[1];
+                                                        match __v_26.as_canonical_u64() {
                                                           0u64 => {
-                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                            let __v_43: G = __loaded[0];
-                                                            let __v_44: G = __loaded[1];
-                                                            let __v_45: G = __loaded[2];
-                                                            match __v_43.as_canonical_u64() {
+                                                            let __v_27: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                            }
+                                                            let __ret: [G; OUT_22] = [__v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27];
+                                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            return Ok(__ret);
+                                                          },
+                                                          _ => {
+                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                            let __v_27: G = __loaded[0];
+                                                            let __v_28: G = __loaded[1];
+                                                            match __v_28.as_canonical_u64() {
                                                               0u64 => {
-                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                let __v_46: G = __loaded[0];
-                                                                let __v_47: G = __loaded[1];
-                                                                let __v_48: G = __loaded[2];
-                                                                match __v_46.as_canonical_u64() {
+                                                                let __v_29: G = G::from_u64(0);
+                                                                let __v_30: G = G::from_u64(1);
+                                                                if (__v_29 != __v_30) {
+                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                }
+                                                                let __ret: [G; OUT_22] = [__v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29];
+                                                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                return Ok(__ret);
+                                                              },
+                                                              _ => {
+                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                let __v_29: G = __loaded[0];
+                                                                let __v_30: G = __loaded[1];
+                                                                match __v_30.as_canonical_u64() {
                                                                   0u64 => {
-                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                    let __v_49: G = __loaded[0];
-                                                                    let __v_50: G = __loaded[1];
-                                                                    let __v_51: G = __loaded[2];
-                                                                    match __v_49.as_canonical_u64() {
+                                                                    let __v_31: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                    }
+                                                                    let __ret: [G; OUT_22] = [__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_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31];
+                                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                    return Ok(__ret);
+                                                                  },
+                                                                  _ => {
+                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                    let __v_31: G = __loaded[0];
+                                                                    let __v_32: G = __loaded[1];
+                                                                    match __v_32.as_canonical_u64() {
                                                                       0u64 => {
-                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                        let __v_52: G = __loaded[0];
-                                                                        let __v_53: G = __loaded[1];
-                                                                        let __v_54: G = __loaded[2];
-                                                                        match __v_52.as_canonical_u64() {
+                                                                        let __v_33: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                        }
+                                                                        let __ret: [G; OUT_22] = [__v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33];
+                                                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                        return Ok(__ret);
+                                                                      },
+                                                                      _ => {
+                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_32.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                        let __v_33: G = __loaded[0];
+                                                                        let __v_34: G = __loaded[1];
+                                                                        match __v_34.as_canonical_u64() {
                                                                           0u64 => {
-                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                            let __v_55: G = __loaded[0];
-                                                                            let __v_56: G = __loaded[1];
-                                                                            let __v_57: G = __loaded[2];
-                                                                            match __v_55.as_canonical_u64() {
+                                                                            let __v_35: G = G::from_u64(0);
+                                                                            let __v_36: G = G::from_u64(1);
+                                                                            if (__v_35 != __v_36) {
+                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                            }
+                                                                            let __ret: [G; OUT_22] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35];
+                                                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                            return Ok(__ret);
+                                                                          },
+                                                                          _ => {
+                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                            let __v_35: G = __loaded[0];
+                                                                            let __v_36: G = __loaded[1];
+                                                                            match __v_36.as_canonical_u64() {
                                                                               0u64 => {
-                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                let __v_58: G = __loaded[0];
-                                                                                let __v_59: G = __loaded[1];
-                                                                                let __v_60: G = __loaded[2];
-                                                                                match __v_58.as_canonical_u64() {
+                                                                                let __v_37: G = G::from_u64(0);
+                                                                                let __v_38: G = G::from_u64(1);
+                                                                                if (__v_37 != __v_38) {
+                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_38.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                }
+                                                                                let __ret: [G; OUT_22] = [__v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
+                                                                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                return Ok(__ret);
+                                                                              },
+                                                                              _ => {
+                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                let __v_37: G = __loaded[0];
+                                                                                let __v_38: G = __loaded[1];
+                                                                                match __v_38.as_canonical_u64() {
                                                                                   0u64 => {
-                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                    let __v_61: G = __loaded[0];
-                                                                                    let __v_62: G = __loaded[1];
-                                                                                    let __v_63: G = __loaded[2];
-                                                                                    match __v_61.as_canonical_u64() {
+                                                                                    let __v_39: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                    }
+                                                                                    let __ret: [G; OUT_22] = [__v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39];
+                                                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                    return Ok(__ret);
+                                                                                  },
+                                                                                  _ => {
+                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_38.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                    let __v_39: G = __loaded[0];
+                                                                                    let __v_40: G = __loaded[1];
+                                                                                    match __v_40.as_canonical_u64() {
                                                                                       0u64 => {
-                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                        let __v_64: G = __loaded[0];
-                                                                                        let __v_65: G = __loaded[1];
-                                                                                        let __v_66: G = __loaded[2];
-                                                                                        match __v_64.as_canonical_u64() {
+                                                                                        let __v_41: G = G::from_u64(0);
+                                                                                        let __v_42: G = G::from_u64(1);
+                                                                                        if (__v_41 != __v_42) {
+                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                        }
+                                                                                        let __ret: [G; OUT_22] = [__v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41];
+                                                                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                        return Ok(__ret);
+                                                                                      },
+                                                                                      _ => {
+                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                        let __v_41: G = __loaded[0];
+                                                                                        let __v_42: G = __loaded[1];
+                                                                                        match __v_42.as_canonical_u64() {
                                                                                           0u64 => {
-                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                            let __v_67: G = __loaded[0];
-                                                                                            let __v_68: G = __loaded[1];
-                                                                                            let __v_69: G = __loaded[2];
-                                                                                            match __v_67.as_canonical_u64() {
+                                                                                            let __v_43: G = G::from_u64(0);
+                                                                                            let __v_44: G = G::from_u64(1);
+                                                                                            if (__v_43 != __v_44) {
+                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                            }
+                                                                                            let __ret: [G; OUT_22] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43];
+                                                                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                            return Ok(__ret);
+                                                                                          },
+                                                                                          _ => {
+                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                            let __v_43: G = __loaded[0];
+                                                                                            let __v_44: G = __loaded[1];
+                                                                                            match __v_44.as_canonical_u64() {
                                                                                               0u64 => {
-                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                let __v_70: G = __loaded[0];
-                                                                                                let __v_71: G = __loaded[1];
-                                                                                                let __v_72: G = __loaded[2];
-                                                                                                match __v_70.as_canonical_u64() {
+                                                                                                let __v_45: G = G::from_u64(0);
+                                                                                                let __v_46: G = G::from_u64(1);
+                                                                                                if (__v_45 != __v_46) {
+                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                }
+                                                                                                let __ret: [G; OUT_22] = [__v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45];
+                                                                                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                return Ok(__ret);
+                                                                                              },
+                                                                                              _ => {
+                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_44.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                let __v_45: G = __loaded[0];
+                                                                                                let __v_46: G = __loaded[1];
+                                                                                                match __v_46.as_canonical_u64() {
                                                                                                   0u64 => {
-                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                    let __v_73: G = __loaded[0];
-                                                                                                    let __v_74: G = __loaded[1];
-                                                                                                    let __v_75: G = __loaded[2];
-                                                                                                    match __v_73.as_canonical_u64() {
+                                                                                                    let __v_47: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                    }
+                                                                                                    let __ret: [G; OUT_22] = [__v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47];
+                                                                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                    return Ok(__ret);
+                                                                                                  },
+                                                                                                  _ => {
+                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_46.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                    let __v_47: G = __loaded[0];
+                                                                                                    let __v_48: G = __loaded[1];
+                                                                                                    match __v_48.as_canonical_u64() {
                                                                                                       0u64 => {
-                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                        let __v_76: G = __loaded[0];
-                                                                                                        let __v_77: G = __loaded[1];
-                                                                                                        let __v_78: G = __loaded[2];
-                                                                                                        match __v_76.as_canonical_u64() {
+                                                                                                        let __v_49: G = G::from_u64(0);
+                                                                                                        let __v_50: G = G::from_u64(1);
+                                                                                                        if (__v_49 != __v_50) {
+                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                        }
+                                                                                                        let __ret: [G; OUT_22] = [__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, __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];
+                                                                                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                        return Ok(__ret);
+                                                                                                      },
+                                                                                                      _ => {
+                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                        let __v_49: G = __loaded[0];
+                                                                                                        let __v_50: G = __loaded[1];
+                                                                                                        match __v_50.as_canonical_u64() {
                                                                                                           0u64 => {
-                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                            let __v_79: G = __loaded[0];
-                                                                                                            let __v_80: G = __loaded[1];
-                                                                                                            let __v_81: G = __loaded[2];
-                                                                                                            match __v_79.as_canonical_u64() {
+                                                                                                            let __v_51: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                            }
+                                                                                                            let __ret: [G; OUT_22] = [__v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51];
+                                                                                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                            return Ok(__ret);
+                                                                                                          },
+                                                                                                          _ => {
+                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                            let __v_51: G = __loaded[0];
+                                                                                                            let __v_52: G = __loaded[1];
+                                                                                                            match __v_52.as_canonical_u64() {
                                                                                                               0u64 => {
-                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                let __v_82: G = __loaded[0];
-                                                                                                                let __v_83: G = __loaded[1];
-                                                                                                                let __v_84: G = __loaded[2];
-                                                                                                                match __v_82.as_canonical_u64() {
+                                                                                                                let __v_53: G = G::from_u64(0);
+                                                                                                                let __v_54: G = G::from_u64(1);
+                                                                                                                if (__v_53 != __v_54) {
+                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                }
+                                                                                                                let __ret: [G; OUT_22] = [__v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53];
+                                                                                                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                return Ok(__ret);
+                                                                                                              },
+                                                                                                              _ => {
+                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_52.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                let __v_53: G = __loaded[0];
+                                                                                                                let __v_54: G = __loaded[1];
+                                                                                                                match __v_54.as_canonical_u64() {
                                                                                                                   0u64 => {
-                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                    let __v_85: G = __loaded[0];
-                                                                                                                    let __v_86: G = __loaded[1];
-                                                                                                                    let __v_87: G = __loaded[2];
-                                                                                                                    match __v_85.as_canonical_u64() {
+                                                                                                                    let __v_55: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                    }
+                                                                                                                    let __ret: [G; OUT_22] = [__v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55];
+                                                                                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                    return Ok(__ret);
+                                                                                                                  },
+                                                                                                                  _ => {
+                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                    let __v_55: G = __loaded[0];
+                                                                                                                    let __v_56: G = __loaded[1];
+                                                                                                                    match __v_56.as_canonical_u64() {
                                                                                                                       0u64 => {
-                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                        let __v_88: G = __loaded[0];
-                                                                                                                        let __v_89: G = __loaded[1];
-                                                                                                                        let __v_90: G = __loaded[2];
-                                                                                                                        match __v_88.as_canonical_u64() {
+                                                                                                                        let __v_57: G = G::from_u64(0);
+                                                                                                                        let __v_58: G = G::from_u64(1);
+                                                                                                                        if (__v_57 != __v_58) {
+                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                        }
+                                                                                                                        let __ret: [G; OUT_22] = [__v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57];
+                                                                                                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                        return Ok(__ret);
+                                                                                                                      },
+                                                                                                                      _ => {
+                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                        let __v_57: G = __loaded[0];
+                                                                                                                        let __v_58: G = __loaded[1];
+                                                                                                                        match __v_58.as_canonical_u64() {
                                                                                                                           0u64 => {
-                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                            let __v_91: G = __loaded[0];
-                                                                                                                            let __v_92: G = __loaded[1];
-                                                                                                                            let __v_93: G = __loaded[2];
-                                                                                                                            match __v_91.as_canonical_u64() {
+                                                                                                                            let __v_59: G = G::from_u64(0);
+                                                                                                                            let __v_60: G = G::from_u64(1);
+                                                                                                                            if (__v_59 != __v_60) {
+                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                            }
+                                                                                                                            let __ret: [G; OUT_22] = [__v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59];
+                                                                                                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                            return Ok(__ret);
+                                                                                                                          },
+                                                                                                                          _ => {
+                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_58.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                            let __v_59: G = __loaded[0];
+                                                                                                                            let __v_60: G = __loaded[1];
+                                                                                                                            match __v_60.as_canonical_u64() {
                                                                                                                               0u64 => {
-                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                let __v_94: G = __loaded[0];
-                                                                                                                                let __v_95: G = __loaded[1];
-                                                                                                                                let __v_96: G = __loaded[2];
-                                                                                                                                match __v_94.as_canonical_u64() {
+                                                                                                                                let __v_61: G = G::from_u64(0);
+                                                                                                                                let __v_62: G = G::from_u64(1);
+                                                                                                                                if (__v_61 != __v_62) {
+                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                }
+                                                                                                                                let __ret: [G; OUT_22] = [__v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61];
+                                                                                                                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                return Ok(__ret);
+                                                                                                                              },
+                                                                                                                              _ => {
+                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                let __v_61: G = __loaded[0];
+                                                                                                                                let __v_62: G = __loaded[1];
+                                                                                                                                match __v_62.as_canonical_u64() {
                                                                                                                                   0u64 => {
-                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                    let __v_97: G = __loaded[0];
-                                                                                                                                    let __v_98: G = __loaded[1];
-                                                                                                                                    let __v_99: G = __loaded[2];
-                                                                                                                                    match __v_97.as_canonical_u64() {
+                                                                                                                                    let __v_63: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                    }
+                                                                                                                                    let __ret: [G; OUT_22] = [__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, __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, __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, __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];
+                                                                                                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                    return Ok(__ret);
+                                                                                                                                  },
+                                                                                                                                  _ => {
+                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_62.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                    let __v_63: G = __loaded[0];
+                                                                                                                                    let __v_64: G = __loaded[1];
+                                                                                                                                    match __v_64.as_canonical_u64() {
                                                                                                                                       0u64 => {
-                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                        let __v_100: G = __loaded[0];
-                                                                                                                                        let __v_101: G = __loaded[1];
-                                                                                                                                        let __v_102: G = __loaded[2];
-                                                                                                                                        match __v_100.as_canonical_u64() {
+                                                                                                                                        let __v_65: G = G::from_u64(0);
+                                                                                                                                        let __v_66: G = G::from_u64(1);
+                                                                                                                                        if (__v_65 != __v_66) {
+                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                        }
+                                                                                                                                        let __ret: [G; OUT_22] = [__v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65];
+                                                                                                                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                        return Ok(__ret);
+                                                                                                                                      },
+                                                                                                                                      _ => {
+                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_64.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                        let __v_65: G = __loaded[0];
+                                                                                                                                        let __v_66: G = __loaded[1];
+                                                                                                                                        match __v_66.as_canonical_u64() {
                                                                                                                                           0u64 => {
-                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                            let __v_103: G = __loaded[0];
-                                                                                                                                            let __v_104: G = __loaded[1];
-                                                                                                                                            let __v_105: G = __loaded[2];
-                                                                                                                                            match __v_103.as_canonical_u64() {
+                                                                                                                                            let __v_67: G = G::from_u64(0);
+                                                                                                                                            let __v_68: G = G::from_u64(1);
+                                                                                                                                            if (__v_67 != __v_68) {
+                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_68.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                            }
+                                                                                                                                            let __ret: [G; OUT_22] = [__v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67];
+                                                                                                                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                            return Ok(__ret);
+                                                                                                                                          },
+                                                                                                                                          _ => {
+                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                            let __v_67: G = __loaded[0];
+                                                                                                                                            let __v_68: G = __loaded[1];
+                                                                                                                                            match __v_68.as_canonical_u64() {
                                                                                                                                               0u64 => {
-                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                let __v_106: G = __loaded[0];
-                                                                                                                                                let __v_107: G = __loaded[1];
-                                                                                                                                                let __v_108: G = __loaded[2];
-                                                                                                                                                match __v_106.as_canonical_u64() {
+                                                                                                                                                let __v_69: G = G::from_u64(0);
+                                                                                                                                                let __v_70: G = G::from_u64(1);
+                                                                                                                                                if (__v_69 != __v_70) {
+                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                }
+                                                                                                                                                let __ret: [G; OUT_22] = [__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, __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[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                return Ok(__ret);
+                                                                                                                                              },
+                                                                                                                                              _ => {
+                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_68.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                let __v_69: G = __loaded[0];
+                                                                                                                                                let __v_70: G = __loaded[1];
+                                                                                                                                                match __v_70.as_canonical_u64() {
                                                                                                                                                   0u64 => {
-                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                    let __v_109: G = __loaded[0];
-                                                                                                                                                    let __v_110: G = __loaded[1];
-                                                                                                                                                    let __v_111: G = __loaded[2];
-                                                                                                                                                    match __v_109.as_canonical_u64() {
+                                                                                                                                                    let __v_71: G = G::from_u64(0);
+                                                                                                                                                    let __v_72: G = G::from_u64(1);
+                                                                                                                                                    if (__v_71 != __v_72) {
+                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_72.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                    }
+                                                                                                                                                    let __ret: [G; OUT_22] = [__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, __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];
+                                                                                                                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                  },
+                                                                                                                                                  _ => {
+                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                    let __v_71: G = __loaded[0];
+                                                                                                                                                    let __v_72: G = __loaded[1];
+                                                                                                                                                    match __v_72.as_canonical_u64() {
                                                                                                                                                       0u64 => {
-                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                        let __v_112: G = __loaded[0];
-                                                                                                                                                        let __v_113: G = __loaded[1];
-                                                                                                                                                        let __v_114: G = __loaded[2];
-                                                                                                                                                        match __v_112.as_canonical_u64() {
+                                                                                                                                                        let __v_73: G = G::from_u64(0);
+                                                                                                                                                        let __v_74: G = G::from_u64(1);
+                                                                                                                                                        if (__v_73 != __v_74) {
+                                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_74.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                        }
+                                                                                                                                                        let __ret: [G; OUT_22] = [__v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73];
+                                                                                                                                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                        return Ok(__ret);
+                                                                                                                                                      },
+                                                                                                                                                      _ => {
+                                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                        let __v_73: G = __loaded[0];
+                                                                                                                                                        let __v_74: G = __loaded[1];
+                                                                                                                                                        match __v_74.as_canonical_u64() {
                                                                                                                                                           0u64 => {
-                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                            let __v_115: G = __loaded[0];
-                                                                                                                                                            let __v_116: G = __loaded[1];
-                                                                                                                                                            let __v_117: G = __loaded[2];
-                                                                                                                                                            match __v_115.as_canonical_u64() {
+                                                                                                                                                            let __v_75: G = G::from_u64(0);
+                                                                                                                                                            let __v_76: G = G::from_u64(1);
+                                                                                                                                                            if (__v_75 != __v_76) {
+                                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_76.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                            }
+                                                                                                                                                            let __ret: [G; OUT_22] = [__v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75];
+                                                                                                                                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                            return Ok(__ret);
+                                                                                                                                                          },
+                                                                                                                                                          _ => {
+                                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_74.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                            let __v_75: G = __loaded[0];
+                                                                                                                                                            let __v_76: G = __loaded[1];
+                                                                                                                                                            match __v_76.as_canonical_u64() {
                                                                                                                                                               0u64 => {
-                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                let __v_118: G = __loaded[0];
-                                                                                                                                                                let __v_119: G = __loaded[1];
-                                                                                                                                                                let __v_120: G = __loaded[2];
-                                                                                                                                                                match __v_118.as_canonical_u64() {
+                                                                                                                                                                let __v_77: G = G::from_u64(0);
+                                                                                                                                                                let __v_78: G = G::from_u64(1);
+                                                                                                                                                                if (__v_77 != __v_78) {
+                                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_78.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                }
+                                                                                                                                                                let __ret: [G; OUT_22] = [__v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77];
+                                                                                                                                                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                return Ok(__ret);
+                                                                                                                                                              },
+                                                                                                                                                              _ => {
+                                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_76.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                let __v_77: G = __loaded[0];
+                                                                                                                                                                let __v_78: G = __loaded[1];
+                                                                                                                                                                match __v_78.as_canonical_u64() {
                                                                                                                                                                   0u64 => {
-                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                    let __v_121: G = __loaded[0];
-                                                                                                                                                                    let __v_122: G = __loaded[1];
-                                                                                                                                                                    let __v_123: G = __loaded[2];
-                                                                                                                                                                    match __v_121.as_canonical_u64() {
+                                                                                                                                                                    let __v_79: G = G::from_u64(0);
+                                                                                                                                                                    let __v_80: G = G::from_u64(1);
+                                                                                                                                                                    if (__v_79 != __v_80) {
+                                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_80.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                    }
+                                                                                                                                                                    let __ret: [G; OUT_22] = [__v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79];
+                                                                                                                                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                  },
+                                                                                                                                                                  _ => {
+                                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                    let __v_79: G = __loaded[0];
+                                                                                                                                                                    let __v_80: G = __loaded[1];
+                                                                                                                                                                    match __v_80.as_canonical_u64() {
                                                                                                                                                                       0u64 => {
-                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                        let __v_124: G = __loaded[0];
-                                                                                                                                                                        let __v_125: G = __loaded[1];
-                                                                                                                                                                        let __v_126: G = __loaded[2];
-                                                                                                                                                                        match __v_124.as_canonical_u64() {
+                                                                                                                                                                        let __v_81: G = G::from_u64(0);
+                                                                                                                                                                        let __v_82: G = G::from_u64(1);
+                                                                                                                                                                        if (__v_81 != __v_82) {
+                                                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_82.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                        }
+                                                                                                                                                                        let __ret: [G; OUT_22] = [__v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81];
+                                                                                                                                                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                        return Ok(__ret);
+                                                                                                                                                                      },
+                                                                                                                                                                      _ => {
+                                                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_80.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                        let __v_81: G = __loaded[0];
+                                                                                                                                                                        let __v_82: G = __loaded[1];
+                                                                                                                                                                        match __v_82.as_canonical_u64() {
                                                                                                                                                                           0u64 => {
-                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                            let __v_127: G = __loaded[0];
-                                                                                                                                                                            let __v_128: G = __loaded[1];
-                                                                                                                                                                            let __v_129: G = __loaded[2];
-                                                                                                                                                                            match __v_127.as_canonical_u64() {
+                                                                                                                                                                            let __v_83: G = G::from_u64(0);
+                                                                                                                                                                            let __v_84: G = G::from_u64(1);
+                                                                                                                                                                            if (__v_83 != __v_84) {
+                                                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_83.as_canonical_u64(), rhs: __v_84.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                            }
+                                                                                                                                                                            let __ret: [G; OUT_22] = [__v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83];
+                                                                                                                                                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                            return Ok(__ret);
+                                                                                                                                                                          },
+                                                                                                                                                                          _ => {
+                                                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_82.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                            let __v_83: G = __loaded[0];
+                                                                                                                                                                            let __v_84: G = __loaded[1];
+                                                                                                                                                                            match __v_84.as_canonical_u64() {
                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                let __v_130: G = __loaded[0];
-                                                                                                                                                                                let __v_131: G = __loaded[1];
-                                                                                                                                                                                let __v_132: G = __loaded[2];
-                                                                                                                                                                                match __v_130.as_canonical_u64() {
+                                                                                                                                                                                let __v_85: G = G::from_u64(0);
+                                                                                                                                                                                let __v_86: G = G::from_u64(1);
+                                                                                                                                                                                if (__v_85 != __v_86) {
+                                                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_86.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                }
+                                                                                                                                                                                let __ret: [G; OUT_22] = [__v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85];
+                                                                                                                                                                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                return Ok(__ret);
+                                                                                                                                                                              },
+                                                                                                                                                                              _ => {
+                                                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                let __v_85: G = __loaded[0];
+                                                                                                                                                                                let __v_86: G = __loaded[1];
+                                                                                                                                                                                match __v_86.as_canonical_u64() {
                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                    let __v_133: G = __loaded[0];
-                                                                                                                                                                                    let __v_134: G = __loaded[1];
-                                                                                                                                                                                    let __v_135: G = __loaded[2];
-                                                                                                                                                                                    match __v_133.as_canonical_u64() {
+                                                                                                                                                                                    let __v_87: G = G::from_u64(0);
+                                                                                                                                                                                    let __v_88: G = G::from_u64(1);
+                                                                                                                                                                                    if (__v_87 != __v_88) {
+                                                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                    }
+                                                                                                                                                                                    let __ret: [G; OUT_22] = [__v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87];
+                                                                                                                                                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                                  },
+                                                                                                                                                                                  _ => {
+                                                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                    let __v_87: G = __loaded[0];
+                                                                                                                                                                                    let __v_88: G = __loaded[1];
+                                                                                                                                                                                    match __v_88.as_canonical_u64() {
                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                        let __v_136: G = __loaded[0];
-                                                                                                                                                                                        let __v_137: G = __loaded[1];
-                                                                                                                                                                                        let __v_138: G = __loaded[2];
-                                                                                                                                                                                        match __v_136.as_canonical_u64() {
+                                                                                                                                                                                        let __v_89: G = G::from_u64(0);
+                                                                                                                                                                                        let __v_90: G = G::from_u64(1);
+                                                                                                                                                                                        if (__v_89 != __v_90) {
+                                                                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_90.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                        }
+                                                                                                                                                                                        let __ret: [G; OUT_22] = [__v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89];
+                                                                                                                                                                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                        return Ok(__ret);
+                                                                                                                                                                                      },
+                                                                                                                                                                                      _ => {
+                                                                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_88.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                        let __v_89: G = __loaded[0];
+                                                                                                                                                                                        let __v_90: G = __loaded[1];
+                                                                                                                                                                                        match __v_90.as_canonical_u64() {
                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                            let __v_139: G = __loaded[0];
-                                                                                                                                                                                            let __v_140: G = __loaded[1];
-                                                                                                                                                                                            let __v_141: G = __loaded[2];
-                                                                                                                                                                                            match __v_139.as_canonical_u64() {
+                                                                                                                                                                                            let __v_91: G = G::from_u64(0);
+                                                                                                                                                                                            let __v_92: G = G::from_u64(1);
+                                                                                                                                                                                            if (__v_91 != __v_92) {
+                                                                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_91.as_canonical_u64(), rhs: __v_92.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                            }
+                                                                                                                                                                                            let __ret: [G; OUT_22] = [__v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91];
+                                                                                                                                                                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                            return Ok(__ret);
+                                                                                                                                                                                          },
+                                                                                                                                                                                          _ => {
+                                                                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                            let __v_91: G = __loaded[0];
+                                                                                                                                                                                            let __v_92: G = __loaded[1];
+                                                                                                                                                                                            match __v_92.as_canonical_u64() {
                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                let __v_142: G = __loaded[0];
-                                                                                                                                                                                                let __v_143: G = __loaded[1];
-                                                                                                                                                                                                let __v_144: G = __loaded[2];
-                                                                                                                                                                                                match __v_142.as_canonical_u64() {
+                                                                                                                                                                                                let __v_93: G = G::from_u64(0);
+                                                                                                                                                                                                let __v_94: G = G::from_u64(1);
+                                                                                                                                                                                                if (__v_93 != __v_94) {
+                                                                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_94.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                }
+                                                                                                                                                                                                let __ret: [G; OUT_22] = [__v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93];
+                                                                                                                                                                                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                return Ok(__ret);
+                                                                                                                                                                                              },
+                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                let __v_93: G = __loaded[0];
+                                                                                                                                                                                                let __v_94: G = __loaded[1];
+                                                                                                                                                                                                match __v_94.as_canonical_u64() {
                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                    let __v_145: G = __loaded[0];
-                                                                                                                                                                                                    let __v_146: G = __loaded[1];
-                                                                                                                                                                                                    let __v_147: G = __loaded[2];
-                                                                                                                                                                                                    match __v_145.as_canonical_u64() {
+                                                                                                                                                                                                    let __v_95: G = G::from_u64(0);
+                                                                                                                                                                                                    let __v_96: G = G::from_u64(1);
+                                                                                                                                                                                                    if (__v_95 != __v_96) {
+                                                                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_96.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                    }
+                                                                                                                                                                                                    let __ret: [G; OUT_22] = [__v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95];
+                                                                                                                                                                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                                                  },
+                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_94.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                    let __v_95: G = __loaded[0];
+                                                                                                                                                                                                    let __v_96: G = __loaded[1];
+                                                                                                                                                                                                    match __v_96.as_canonical_u64() {
                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                        let __v_148: G = __loaded[0];
-                                                                                                                                                                                                        let __v_149: G = __loaded[1];
-                                                                                                                                                                                                        let __v_150: G = __loaded[2];
-                                                                                                                                                                                                        match __v_148.as_canonical_u64() {
+                                                                                                                                                                                                        let __v_97: G = G::from_u64(0);
+                                                                                                                                                                                                        let __v_98: G = G::from_u64(1);
+                                                                                                                                                                                                        if (__v_97 != __v_98) {
+                                                                                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_98.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                        }
+                                                                                                                                                                                                        let __ret: [G; OUT_22] = [__v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97];
+                                                                                                                                                                                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                        return Ok(__ret);
+                                                                                                                                                                                                      },
+                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                        let __v_97: G = __loaded[0];
+                                                                                                                                                                                                        let __v_98: G = __loaded[1];
+                                                                                                                                                                                                        match __v_98.as_canonical_u64() {
                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                            let __v_151: G = __loaded[0];
-                                                                                                                                                                                                            let __v_152: G = __loaded[1];
-                                                                                                                                                                                                            let __v_153: G = __loaded[2];
-                                                                                                                                                                                                            match __v_151.as_canonical_u64() {
+                                                                                                                                                                                                            let __v_99: G = G::from_u64(0);
+                                                                                                                                                                                                            let __v_100: G = G::from_u64(1);
+                                                                                                                                                                                                            if (__v_99 != __v_100) {
+                                                                                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                            }
+                                                                                                                                                                                                            let __ret: [G; OUT_22] = [__v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99];
+                                                                                                                                                                                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                            return Ok(__ret);
+                                                                                                                                                                                                          },
+                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_98.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                            let __v_99: G = __loaded[0];
+                                                                                                                                                                                                            let __v_100: G = __loaded[1];
+                                                                                                                                                                                                            match __v_100.as_canonical_u64() {
                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                let __v_154: G = __loaded[0];
-                                                                                                                                                                                                                let __v_155: G = __loaded[1];
-                                                                                                                                                                                                                let __v_156: G = __loaded[2];
-                                                                                                                                                                                                                match __v_154.as_canonical_u64() {
+                                                                                                                                                                                                                let __v_101: G = G::from_u64(0);
+                                                                                                                                                                                                                let __v_102: G = G::from_u64(1);
+                                                                                                                                                                                                                if (__v_101 != __v_102) {
+                                                                                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_101.as_canonical_u64(), rhs: __v_102.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                }
+                                                                                                                                                                                                                let __ret: [G; OUT_22] = [__v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101];
+                                                                                                                                                                                                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                return Ok(__ret);
+                                                                                                                                                                                                              },
+                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                let __v_101: G = __loaded[0];
+                                                                                                                                                                                                                let __v_102: G = __loaded[1];
+                                                                                                                                                                                                                match __v_102.as_canonical_u64() {
                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                    let __v_157: G = __loaded[0];
-                                                                                                                                                                                                                    let __v_158: G = __loaded[1];
-                                                                                                                                                                                                                    let __v_159: G = __loaded[2];
-                                                                                                                                                                                                                    match __v_157.as_canonical_u64() {
+                                                                                                                                                                                                                    let __v_103: G = G::from_u64(0);
+                                                                                                                                                                                                                    let __v_104: G = G::from_u64(1);
+                                                                                                                                                                                                                    if (__v_103 != __v_104) {
+                                                                                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_103.as_canonical_u64(), rhs: __v_104.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                    let __ret: [G; OUT_22] = [__v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103];
+                                                                                                                                                                                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                    let __v_103: G = __loaded[0];
+                                                                                                                                                                                                                    let __v_104: G = __loaded[1];
+                                                                                                                                                                                                                    match __v_104.as_canonical_u64() {
                                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                        let __v_160: G = __loaded[0];
-                                                                                                                                                                                                                        let __v_161: G = __loaded[1];
-                                                                                                                                                                                                                        let __v_162: G = __loaded[2];
-                                                                                                                                                                                                                        match __v_160.as_canonical_u64() {
+                                                                                                                                                                                                                        let __v_105: G = G::from_u64(0);
+                                                                                                                                                                                                                        let __v_106: G = G::from_u64(1);
+                                                                                                                                                                                                                        if (__v_105 != __v_106) {
+                                                                                                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_105.as_canonical_u64(), rhs: __v_106.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                        let __ret: [G; OUT_22] = [__v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105];
+                                                                                                                                                                                                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                        return Ok(__ret);
+                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_104.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                        let __v_105: G = __loaded[0];
+                                                                                                                                                                                                                        let __v_106: G = __loaded[1];
+                                                                                                                                                                                                                        match __v_106.as_canonical_u64() {
                                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                            let __v_163: G = __loaded[0];
-                                                                                                                                                                                                                            let __v_164: G = __loaded[1];
-                                                                                                                                                                                                                            let __v_165: G = __loaded[2];
-                                                                                                                                                                                                                            match __v_163.as_canonical_u64() {
+                                                                                                                                                                                                                            let __v_107: G = G::from_u64(0);
+                                                                                                                                                                                                                            let __v_108: G = G::from_u64(1);
+                                                                                                                                                                                                                            if (__v_107 != __v_108) {
+                                                                                                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_107.as_canonical_u64(), rhs: __v_108.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                            let __ret: [G; OUT_22] = [__v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107];
+                                                                                                                                                                                                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                            return Ok(__ret);
+                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_106.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                            let __v_107: G = __loaded[0];
+                                                                                                                                                                                                                            let __v_108: G = __loaded[1];
+                                                                                                                                                                                                                            match __v_108.as_canonical_u64() {
                                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                let __v_166: G = __loaded[0];
-                                                                                                                                                                                                                                let __v_167: G = __loaded[1];
-                                                                                                                                                                                                                                let __v_168: G = __loaded[2];
-                                                                                                                                                                                                                                match __v_166.as_canonical_u64() {
+                                                                                                                                                                                                                                let __v_109: G = G::from_u64(0);
+                                                                                                                                                                                                                                let __v_110: G = G::from_u64(1);
+                                                                                                                                                                                                                                if (__v_109 != __v_110) {
+                                                                                                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_109.as_canonical_u64(), rhs: __v_110.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                let __ret: [G; OUT_22] = [__v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109];
+                                                                                                                                                                                                                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                return Ok(__ret);
+                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                let __v_109: G = __loaded[0];
+                                                                                                                                                                                                                                let __v_110: G = __loaded[1];
+                                                                                                                                                                                                                                match __v_110.as_canonical_u64() {
                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                    let __v_169: G = __loaded[0];
-                                                                                                                                                                                                                                    let __v_170: G = __loaded[1];
-                                                                                                                                                                                                                                    let __v_171: G = __loaded[2];
-                                                                                                                                                                                                                                    match __v_169.as_canonical_u64() {
+                                                                                                                                                                                                                                    let __v_111: G = G::from_u64(0);
+                                                                                                                                                                                                                                    let __v_112: G = G::from_u64(1);
+                                                                                                                                                                                                                                    if (__v_111 != __v_112) {
+                                                                                                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_111.as_canonical_u64(), rhs: __v_112.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                    let __ret: [G; OUT_22] = [__v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111];
+                                                                                                                                                                                                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_110.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                    let __v_111: G = __loaded[0];
+                                                                                                                                                                                                                                    let __v_112: G = __loaded[1];
+                                                                                                                                                                                                                                    match __v_112.as_canonical_u64() {
                                                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                        let __v_172: G = __loaded[0];
-                                                                                                                                                                                                                                        let __v_173: G = __loaded[1];
-                                                                                                                                                                                                                                        let __v_174: G = __loaded[2];
-                                                                                                                                                                                                                                        match __v_172.as_canonical_u64() {
+                                                                                                                                                                                                                                        let __v_113: G = G::from_u64(0);
+                                                                                                                                                                                                                                        let __v_114: G = G::from_u64(1);
+                                                                                                                                                                                                                                        if (__v_113 != __v_114) {
+                                                                                                                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_113.as_canonical_u64(), rhs: __v_114.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                        let __ret: [G; OUT_22] = [__v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113];
+                                                                                                                                                                                                                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                        return Ok(__ret);
+                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_112.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                        let __v_113: G = __loaded[0];
+                                                                                                                                                                                                                                        let __v_114: G = __loaded[1];
+                                                                                                                                                                                                                                        match __v_114.as_canonical_u64() {
                                                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                            let __v_175: G = __loaded[0];
-                                                                                                                                                                                                                                            let __v_176: G = __loaded[1];
-                                                                                                                                                                                                                                            let __v_177: G = __loaded[2];
-                                                                                                                                                                                                                                            match __v_175.as_canonical_u64() {
+                                                                                                                                                                                                                                            let __v_115: G = G::from_u64(0);
+                                                                                                                                                                                                                                            let __v_116: G = G::from_u64(1);
+                                                                                                                                                                                                                                            if (__v_115 != __v_116) {
+                                                                                                                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_115.as_canonical_u64(), rhs: __v_116.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                            let __ret: [G; OUT_22] = [__v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115];
+                                                                                                                                                                                                                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                            return Ok(__ret);
+                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                            let __v_115: G = __loaded[0];
+                                                                                                                                                                                                                                            let __v_116: G = __loaded[1];
+                                                                                                                                                                                                                                            match __v_116.as_canonical_u64() {
                                                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                let __v_178: G = __loaded[0];
-                                                                                                                                                                                                                                                let __v_179: G = __loaded[1];
-                                                                                                                                                                                                                                                let __v_180: G = __loaded[2];
-                                                                                                                                                                                                                                                match __v_178.as_canonical_u64() {
+                                                                                                                                                                                                                                                let __v_117: G = G::from_u64(0);
+                                                                                                                                                                                                                                                let __v_118: G = G::from_u64(1);
+                                                                                                                                                                                                                                                if (__v_117 != __v_118) {
+                                                                                                                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_118.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                let __ret: [G; OUT_22] = [__v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117];
+                                                                                                                                                                                                                                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                return Ok(__ret);
+                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_116.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                let __v_117: G = __loaded[0];
+                                                                                                                                                                                                                                                let __v_118: G = __loaded[1];
+                                                                                                                                                                                                                                                match __v_118.as_canonical_u64() {
                                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                    let __v_181: G = __loaded[0];
-                                                                                                                                                                                                                                                    let __v_182: G = __loaded[1];
-                                                                                                                                                                                                                                                    let __v_183: G = __loaded[2];
-                                                                                                                                                                                                                                                    match __v_181.as_canonical_u64() {
+                                                                                                                                                                                                                                                    let __v_119: G = G::from_u64(0);
+                                                                                                                                                                                                                                                    let __v_120: G = G::from_u64(1);
+                                                                                                                                                                                                                                                    if (__v_119 != __v_120) {
+                                                                                                                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_119.as_canonical_u64(), rhs: __v_120.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                    let __ret: [G; OUT_22] = [__v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119];
+                                                                                                                                                                                                                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_118.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                    let __v_119: G = __loaded[0];
+                                                                                                                                                                                                                                                    let __v_120: G = __loaded[1];
+                                                                                                                                                                                                                                                    match __v_120.as_canonical_u64() {
                                                                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                        let __v_184: G = __loaded[0];
-                                                                                                                                                                                                                                                        let __v_185: G = __loaded[1];
-                                                                                                                                                                                                                                                        let __v_186: G = __loaded[2];
-                                                                                                                                                                                                                                                        match __v_184.as_canonical_u64() {
+                                                                                                                                                                                                                                                        let __v_121: G = G::from_u64(0);
+                                                                                                                                                                                                                                                        let __v_122: G = G::from_u64(1);
+                                                                                                                                                                                                                                                        if (__v_121 != __v_122) {
+                                                                                                                                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_121.as_canonical_u64(), rhs: __v_122.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                        let __ret: [G; OUT_22] = [__v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121];
+                                                                                                                                                                                                                                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                        return Ok(__ret);
+                                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                        let __v_121: G = __loaded[0];
+                                                                                                                                                                                                                                                        let __v_122: G = __loaded[1];
+                                                                                                                                                                                                                                                        match __v_122.as_canonical_u64() {
                                                                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                            let __v_187: G = __loaded[0];
-                                                                                                                                                                                                                                                            let __v_188: G = __loaded[1];
-                                                                                                                                                                                                                                                            let __v_189: G = __loaded[2];
-                                                                                                                                                                                                                                                            match __v_187.as_canonical_u64() {
+                                                                                                                                                                                                                                                            let __v_123: G = G::from_u64(0);
+                                                                                                                                                                                                                                                            let __v_124: G = G::from_u64(1);
+                                                                                                                                                                                                                                                            if (__v_123 != __v_124) {
+                                                                                                                                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_124.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                            let __ret: [G; OUT_22] = [__v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123];
+                                                                                                                                                                                                                                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                            return Ok(__ret);
+                                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_122.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                            let __v_123: G = __loaded[0];
+                                                                                                                                                                                                                                                            let __v_124: G = __loaded[1];
+                                                                                                                                                                                                                                                            match __v_124.as_canonical_u64() {
                                                                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                                let __v_190: G = __loaded[0];
-                                                                                                                                                                                                                                                                let __v_191: G = __loaded[1];
-                                                                                                                                                                                                                                                                let __v_192: G = __loaded[2];
-                                                                                                                                                                                                                                                                match __v_190.as_canonical_u64() {
+                                                                                                                                                                                                                                                                let __v_125: G = G::from_u64(0);
+                                                                                                                                                                                                                                                                let __v_126: G = G::from_u64(1);
+                                                                                                                                                                                                                                                                if (__v_125 != __v_126) {
+                                                                                                                                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                let __ret: [G; OUT_22] = [__v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125];
+                                                                                                                                                                                                                                                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                                return Ok(__ret);
+                                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_124.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                                let __v_125: G = __loaded[0];
+                                                                                                                                                                                                                                                                let __v_126: G = __loaded[1];
+                                                                                                                                                                                                                                                                match __v_126.as_canonical_u64() {
                                                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                                                    let __ret: [G; OUT_22] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2];
+                                                                                                                                                                                                                                                                    let __v_127: G = G::from_u64(0);
+                                                                                                                                                                                                                                                                    let __v_128: G = G::from_u64(1);
+                                                                                                                                                                                                                                                                    if (__v_127 != __v_128) {
+                                                                                                                                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_127.as_canonical_u64(), rhs: __v_128.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                    let __ret: [G; OUT_22] = [__v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127];
                                                                                                                                                                                                                                                                     record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                                                                                                                                                                     return Ok(__ret);
                                                                                                                                                                                                                                                                   },
                                                                                                                                                                                                                                                                   _ => {
-                                                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_190.as_canonical_u64()));
+                                                                                                                                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                                    let __v_127: G = __loaded[0];
+                                                                                                                                                                                                                                                                    let __v_128: G = __loaded[1];
+                                                                                                                                                                                                                                                                    let __ret: [G; OUT_22] = [__v_127, __v_125, __v_123, __v_121, __v_119, __v_117, __v_115, __v_113, __v_111, __v_109, __v_107, __v_105, __v_103, __v_101, __v_99, __v_97, __v_95, __v_93, __v_91, __v_89, __v_87, __v_85, __v_83, __v_81, __v_79, __v_77, __v_75, __v_73, __v_71, __v_69, __v_67, __v_65, __v_63, __v_61, __v_59, __v_57, __v_55, __v_53, __v_51, __v_49, __v_47, __v_45, __v_43, __v_41, __v_39, __v_37, __v_35, __v_33, __v_31, __v_29, __v_27, __v_25, __v_23, __v_21, __v_19, __v_17, __v_15, __v_13, __v_11, __v_9, __v_7, __v_5, __v_3, __v_1];
+                                                                                                                                                                                                                                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                                    return Ok(__ret);
                                                                                                                                                                                                                                                                   },
                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                               },
-                                                                                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_187.as_canonical_u64()));
-                                                                                                                                                                                                                                                              },
                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                           },
-                                                                                                                                                                                                                                                          _ => {
-                                                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_184.as_canonical_u64()));
-                                                                                                                                                                                                                                                          },
                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                       },
-                                                                                                                                                                                                                                                      _ => {
-                                                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_181.as_canonical_u64()));
-                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                     }
                                                                                                                                                                                                                                                   },
-                                                                                                                                                                                                                                                  _ => {
-                                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_178.as_canonical_u64()));
-                                                                                                                                                                                                                                                  },
                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                               },
-                                                                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_175.as_canonical_u64()));
-                                                                                                                                                                                                                                              },
                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                           },
-                                                                                                                                                                                                                                          _ => {
-                                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_172.as_canonical_u64()));
-                                                                                                                                                                                                                                          },
                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                       },
-                                                                                                                                                                                                                                      _ => {
-                                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_169.as_canonical_u64()));
-                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                     }
                                                                                                                                                                                                                                   },
-                                                                                                                                                                                                                                  _ => {
-                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_166.as_canonical_u64()));
-                                                                                                                                                                                                                                  },
                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                               },
-                                                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_163.as_canonical_u64()));
-                                                                                                                                                                                                                              },
                                                                                                                                                                                                                             }
                                                                                                                                                                                                                           },
-                                                                                                                                                                                                                          _ => {
-                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64()));
-                                                                                                                                                                                                                          },
                                                                                                                                                                                                                         }
                                                                                                                                                                                                                       },
-                                                                                                                                                                                                                      _ => {
-                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_157.as_canonical_u64()));
-                                                                                                                                                                                                                      },
                                                                                                                                                                                                                     }
                                                                                                                                                                                                                   },
-                                                                                                                                                                                                                  _ => {
-                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_154.as_canonical_u64()));
-                                                                                                                                                                                                                  },
                                                                                                                                                                                                                 }
                                                                                                                                                                                                               },
-                                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_151.as_canonical_u64()));
-                                                                                                                                                                                                              },
                                                                                                                                                                                                             }
                                                                                                                                                                                                           },
-                                                                                                                                                                                                          _ => {
-                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_148.as_canonical_u64()));
-                                                                                                                                                                                                          },
                                                                                                                                                                                                         }
                                                                                                                                                                                                       },
-                                                                                                                                                                                                      _ => {
-                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_145.as_canonical_u64()));
-                                                                                                                                                                                                      },
                                                                                                                                                                                                     }
                                                                                                                                                                                                   },
-                                                                                                                                                                                                  _ => {
-                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_142.as_canonical_u64()));
-                                                                                                                                                                                                  },
                                                                                                                                                                                                 }
                                                                                                                                                                                               },
-                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_139.as_canonical_u64()));
-                                                                                                                                                                                              },
                                                                                                                                                                                             }
                                                                                                                                                                                           },
-                                                                                                                                                                                          _ => {
-                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_136.as_canonical_u64()));
-                                                                                                                                                                                          },
                                                                                                                                                                                         }
                                                                                                                                                                                       },
-                                                                                                                                                                                      _ => {
-                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64()));
-                                                                                                                                                                                      },
                                                                                                                                                                                     }
                                                                                                                                                                                   },
-                                                                                                                                                                                  _ => {
-                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_130.as_canonical_u64()));
-                                                                                                                                                                                  },
                                                                                                                                                                                 }
                                                                                                                                                                               },
-                                                                                                                                                                              _ => {
-                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_127.as_canonical_u64()));
-                                                                                                                                                                              },
                                                                                                                                                                             }
                                                                                                                                                                           },
-                                                                                                                                                                          _ => {
-                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64()));
-                                                                                                                                                                          },
                                                                                                                                                                         }
                                                                                                                                                                       },
-                                                                                                                                                                      _ => {
-                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64()));
-                                                                                                                                                                      },
                                                                                                                                                                     }
                                                                                                                                                                   },
-                                                                                                                                                                  _ => {
-                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64()));
-                                                                                                                                                                  },
                                                                                                                                                                 }
                                                                                                                                                               },
-                                                                                                                                                              _ => {
-                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64()));
-                                                                                                                                                              },
                                                                                                                                                             }
                                                                                                                                                           },
-                                                                                                                                                          _ => {
-                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64()));
-                                                                                                                                                          },
                                                                                                                                                         }
                                                                                                                                                       },
-                                                                                                                                                      _ => {
-                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64()));
-                                                                                                                                                      },
                                                                                                                                                     }
                                                                                                                                                   },
-                                                                                                                                                  _ => {
-                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64()));
-                                                                                                                                                  },
                                                                                                                                                 }
                                                                                                                                               },
-                                                                                                                                              _ => {
-                                                                                                                                                return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64()));
-                                                                                                                                              },
                                                                                                                                             }
                                                                                                                                           },
-                                                                                                                                          _ => {
-                                                                                                                                            return Err(ExecError::MatchNoCase(__v_100.as_canonical_u64()));
-                                                                                                                                          },
                                                                                                                                         }
                                                                                                                                       },
-                                                                                                                                      _ => {
-                                                                                                                                        return Err(ExecError::MatchNoCase(__v_97.as_canonical_u64()));
-                                                                                                                                      },
                                                                                                                                     }
                                                                                                                                   },
-                                                                                                                                  _ => {
-                                                                                                                                    return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64()));
-                                                                                                                                  },
                                                                                                                                 }
                                                                                                                               },
-                                                                                                                              _ => {
-                                                                                                                                return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64()));
-                                                                                                                              },
                                                                                                                             }
                                                                                                                           },
-                                                                                                                          _ => {
-                                                                                                                            return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64()));
-                                                                                                                          },
                                                                                                                         }
                                                                                                                       },
-                                                                                                                      _ => {
-                                                                                                                        return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64()));
-                                                                                                                      },
                                                                                                                     }
                                                                                                                   },
-                                                                                                                  _ => {
-                                                                                                                    return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64()));
-                                                                                                                  },
                                                                                                                 }
                                                                                                               },
-                                                                                                              _ => {
-                                                                                                                return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64()));
-                                                                                                              },
                                                                                                             }
                                                                                                           },
-                                                                                                          _ => {
-                                                                                                            return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64()));
-                                                                                                          },
                                                                                                         }
                                                                                                       },
-                                                                                                      _ => {
-                                                                                                        return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64()));
-                                                                                                      },
                                                                                                     }
                                                                                                   },
-                                                                                                  _ => {
-                                                                                                    return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64()));
-                                                                                                  },
                                                                                                 }
                                                                                               },
-                                                                                              _ => {
-                                                                                                return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64()));
-                                                                                              },
                                                                                             }
                                                                                           },
-                                                                                          _ => {
-                                                                                            return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64()));
-                                                                                          },
                                                                                         }
                                                                                       },
-                                                                                      _ => {
-                                                                                        return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
-                                                                                      },
                                                                                     }
                                                                                   },
-                                                                                  _ => {
-                                                                                    return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64()));
-                                                                                  },
                                                                                 }
                                                                               },
-                                                                              _ => {
-                                                                                return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64()));
-                                                                              },
                                                                             }
                                                                           },
-                                                                          _ => {
-                                                                            return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64()));
-                                                                          },
                                                                         }
                                                                       },
-                                                                      _ => {
-                                                                        return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64()));
-                                                                      },
                                                                     }
                                                                   },
-                                                                  _ => {
-                                                                    return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64()));
-                                                                  },
                                                                 }
                                                               },
-                                                              _ => {
-                                                                return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64()));
-                                                              },
                                                             }
                                                           },
-                                                          _ => {
-                                                            return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64()));
-                                                          },
                                                         }
                                                       },
-                                                      _ => {
-                                                        return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64()));
-                                                      },
                                                     }
                                                   },
-                                                  _ => {
-                                                    return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
-                                                  },
                                                 }
                                               },
-                                              _ => {
-                                                return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
-                                              },
                                             }
                                           },
-                                          _ => {
-                                            return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
-                                          },
                                         }
                                       },
-                                      _ => {
-                                        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
-                                      },
                                     }
                                   },
-                                  _ => {
-                                    return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
-                                  },
                                 }
                               },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
-                              },
                             }
                           },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-                          },
                         }
                       },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-                      },
                     }
                   },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-                  },
                 }
               },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-              },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -4376,13 +4544,12 @@ fn aiur_fn_23(
       },
       _ => {
         let __v_2: G = G::from_u64(0);
-        let __v_3: G = G::from_u64(0);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = (__v_1 - __v_5);
-        let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_23] = [__v_7];
+        let __v_3: G = { let __values: [G; 2] = [__v_2, __v_0]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
+        let __ret: [G; OUT_23] = [__v_6];
         record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -4413,7 +4580,7 @@ fn aiur_fn_24(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+            let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
             let __v_9: G = __loaded[0];
             let __v_10: G = __loaded[1];
             let __v_11: G = __loaded[2];
@@ -4440,40 +4607,40 @@ fn aiur_fn_24(
                                           0u64 => {
                                             let __v_17: G = (__v_6 + __v_7);
                                             let __v_18: G = (__v_8 + __v_17);
-                                            let __v_19: G = G::from_u64(0);
-                                            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-                                            let __v_20: G = __loaded[0];
-                                            let __v_21: G = __loaded[1];
-                                            let __v_22: G = __loaded[2];
-                                            let __v_23: G = __loaded[3];
-                                            let __v_24: G = __loaded[4];
-                                            let __v_25: G = __loaded[5];
-                                            let __v_26: G = __loaded[6];
-                                            let __v_27: G = __loaded[7];
-                                            let __v_28: G = __loaded[8];
-                                            let __v_29: G = __loaded[9];
-                                            let __v_30: G = __loaded[10];
-                                            let __v_31: G = __loaded[11];
-                                            let __v_32: G = __loaded[12];
-                                            let __v_33: G = __loaded[13];
-                                            let __v_34: G = __loaded[14];
-                                            let __v_35: G = __loaded[15];
-                                            let __v_36: G = __loaded[16];
-                                            let __v_37: G = __loaded[17];
-                                            let __v_38: G = __loaded[18];
-                                            let __v_39: G = __loaded[19];
-                                            let __v_40: G = __loaded[20];
-                                            let __v_41: G = __loaded[21];
-                                            let __v_42: G = __loaded[22];
-                                            let __v_43: G = __loaded[23];
-                                            let __v_44: G = __loaded[24];
-                                            let __v_45: G = __loaded[25];
-                                            let __v_46: G = __loaded[26];
-                                            let __v_47: G = __loaded[27];
-                                            let __v_48: G = __loaded[28];
-                                            let __v_49: G = __loaded[29];
-                                            let __v_50: G = __loaded[30];
-                                            let __v_51: G = __loaded[31];
+                                            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+                                            let __v_19: G = __loaded[0];
+                                            let __v_20: G = __loaded[1];
+                                            let __v_21: G = __loaded[2];
+                                            let __v_22: G = __loaded[3];
+                                            let __v_23: G = __loaded[4];
+                                            let __v_24: G = __loaded[5];
+                                            let __v_25: G = __loaded[6];
+                                            let __v_26: G = __loaded[7];
+                                            let __v_27: G = __loaded[8];
+                                            let __v_28: G = __loaded[9];
+                                            let __v_29: G = __loaded[10];
+                                            let __v_30: G = __loaded[11];
+                                            let __v_31: G = __loaded[12];
+                                            let __v_32: G = __loaded[13];
+                                            let __v_33: G = __loaded[14];
+                                            let __v_34: G = __loaded[15];
+                                            let __v_35: G = __loaded[16];
+                                            let __v_36: G = __loaded[17];
+                                            let __v_37: G = __loaded[18];
+                                            let __v_38: G = __loaded[19];
+                                            let __v_39: G = __loaded[20];
+                                            let __v_40: G = __loaded[21];
+                                            let __v_41: G = __loaded[22];
+                                            let __v_42: G = __loaded[23];
+                                            let __v_43: G = __loaded[24];
+                                            let __v_44: G = __loaded[25];
+                                            let __v_45: G = __loaded[26];
+                                            let __v_46: G = __loaded[27];
+                                            let __v_47: G = __loaded[28];
+                                            let __v_48: G = __loaded[29];
+                                            let __v_49: G = __loaded[30];
+                                            let __v_50: G = __loaded[31];
+                                            let __v_51: G = G::from_u64(0);
                                             let __v_52: G = G::from_u64(0);
                                             let __v_53: G = G::from_u64(0);
                                             let __v_54: G = G::from_u64(0);
@@ -4537,52 +4704,51 @@ fn aiur_fn_24(
                                             let __v_112: G = G::from_u64(0);
                                             let __v_113: G = G::from_u64(0);
                                             let __v_114: G = G::from_u64(0);
-                                            let __v_115: G = G::from_u64(0);
-                                            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-                                            let __v_116: G = __loaded[0];
-                                            let __v_117: G = __loaded[1];
-                                            let __v_118: G = __loaded[2];
-                                            let __v_119: G = __loaded[3];
-                                            let __v_120: G = __loaded[4];
-                                            let __v_121: G = __loaded[5];
-                                            let __v_122: G = __loaded[6];
-                                            let __v_123: G = __loaded[7];
-                                            let __v_124: G = G::from_u64(0);
-                                            let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
-                                            let __v_125: G = __r_arr[0];
-                                            let __v_126: G = __r_arr[1];
-                                            let __v_127: G = __r_arr[2];
-                                            let __v_128: G = __r_arr[3];
-                                            let __v_129: G = __r_arr[4];
-                                            let __v_130: G = __r_arr[5];
-                                            let __v_131: G = __r_arr[6];
-                                            let __v_132: G = __r_arr[7];
-                                            let __v_133: G = __r_arr[8];
-                                            let __v_134: G = __r_arr[9];
-                                            let __v_135: G = __r_arr[10];
-                                            let __v_136: G = __r_arr[11];
-                                            let __v_137: G = __r_arr[12];
-                                            let __v_138: G = __r_arr[13];
-                                            let __v_139: G = __r_arr[14];
-                                            let __v_140: G = __r_arr[15];
-                                            let __v_141: G = __r_arr[16];
-                                            let __v_142: G = __r_arr[17];
-                                            let __v_143: G = __r_arr[18];
-                                            let __v_144: G = __r_arr[19];
-                                            let __v_145: G = __r_arr[20];
-                                            let __v_146: G = __r_arr[21];
-                                            let __v_147: G = __r_arr[22];
-                                            let __v_148: G = __r_arr[23];
-                                            let __v_149: G = __r_arr[24];
-                                            let __v_150: G = __r_arr[25];
-                                            let __v_151: G = __r_arr[26];
-                                            let __v_152: G = __r_arr[27];
-                                            let __v_153: G = __r_arr[28];
-                                            let __v_154: G = __r_arr[29];
-                                            let __v_155: G = __r_arr[30];
-                                            let __v_156: G = __r_arr[31];
-                                            let __v_157: G = { let __values: [G; 34] = [__v_19, __v_5, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_24] = [__v_157];
+                                            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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                                            let __v_115: G = __loaded[0];
+                                            let __v_116: G = __loaded[1];
+                                            let __v_117: G = __loaded[2];
+                                            let __v_118: G = __loaded[3];
+                                            let __v_119: G = __loaded[4];
+                                            let __v_120: G = __loaded[5];
+                                            let __v_121: G = __loaded[6];
+                                            let __v_122: G = __loaded[7];
+                                            let __v_123: G = G::from_u64(0);
+                                            let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+                                            let __v_124: G = __r_arr[0];
+                                            let __v_125: G = __r_arr[1];
+                                            let __v_126: G = __r_arr[2];
+                                            let __v_127: G = __r_arr[3];
+                                            let __v_128: G = __r_arr[4];
+                                            let __v_129: G = __r_arr[5];
+                                            let __v_130: G = __r_arr[6];
+                                            let __v_131: G = __r_arr[7];
+                                            let __v_132: G = __r_arr[8];
+                                            let __v_133: G = __r_arr[9];
+                                            let __v_134: G = __r_arr[10];
+                                            let __v_135: G = __r_arr[11];
+                                            let __v_136: G = __r_arr[12];
+                                            let __v_137: G = __r_arr[13];
+                                            let __v_138: G = __r_arr[14];
+                                            let __v_139: G = __r_arr[15];
+                                            let __v_140: G = __r_arr[16];
+                                            let __v_141: G = __r_arr[17];
+                                            let __v_142: G = __r_arr[18];
+                                            let __v_143: G = __r_arr[19];
+                                            let __v_144: G = __r_arr[20];
+                                            let __v_145: G = __r_arr[21];
+                                            let __v_146: G = __r_arr[22];
+                                            let __v_147: G = __r_arr[23];
+                                            let __v_148: G = __r_arr[24];
+                                            let __v_149: G = __r_arr[25];
+                                            let __v_150: G = __r_arr[26];
+                                            let __v_151: G = __r_arr[27];
+                                            let __v_152: G = __r_arr[28];
+                                            let __v_153: G = __r_arr[29];
+                                            let __v_154: G = __r_arr[30];
+                                            let __v_155: G = __r_arr[31];
+                                            let __v_156: G = { let __values: [G; 33] = [__v_5, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __ret: [G; OUT_24] = [__v_156];
                                             record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
@@ -4643,49 +4809,48 @@ fn aiur_fn_24(
             }
           },
           _ => {
-            let __v_9: G = G::from_u64(0);
-            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-            let __v_10: G = __loaded[0];
-            let __v_11: G = __loaded[1];
-            let __v_12: G = __loaded[2];
-            let __v_13: G = __loaded[3];
-            let __v_14: G = __loaded[4];
-            let __v_15: G = __loaded[5];
-            let __v_16: G = __loaded[6];
-            let __v_17: G = __loaded[7];
-            let __v_18: G = __loaded[8];
-            let __v_19: G = __loaded[9];
-            let __v_20: G = __loaded[10];
-            let __v_21: G = __loaded[11];
-            let __v_22: G = __loaded[12];
-            let __v_23: G = __loaded[13];
-            let __v_24: G = __loaded[14];
-            let __v_25: G = __loaded[15];
-            let __v_26: G = __loaded[16];
-            let __v_27: G = __loaded[17];
-            let __v_28: G = __loaded[18];
-            let __v_29: G = __loaded[19];
-            let __v_30: G = __loaded[20];
-            let __v_31: G = __loaded[21];
-            let __v_32: G = __loaded[22];
-            let __v_33: G = __loaded[23];
-            let __v_34: G = __loaded[24];
-            let __v_35: G = __loaded[25];
-            let __v_36: G = __loaded[26];
-            let __v_37: G = __loaded[27];
-            let __v_38: G = __loaded[28];
-            let __v_39: G = __loaded[29];
-            let __v_40: G = __loaded[30];
-            let __v_41: G = __loaded[31];
-            let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_24] = [__v_42];
+            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_9: G = __loaded[0];
+            let __v_10: G = __loaded[1];
+            let __v_11: G = __loaded[2];
+            let __v_12: G = __loaded[3];
+            let __v_13: G = __loaded[4];
+            let __v_14: G = __loaded[5];
+            let __v_15: G = __loaded[6];
+            let __v_16: G = __loaded[7];
+            let __v_17: G = __loaded[8];
+            let __v_18: G = __loaded[9];
+            let __v_19: G = __loaded[10];
+            let __v_20: G = __loaded[11];
+            let __v_21: G = __loaded[12];
+            let __v_22: G = __loaded[13];
+            let __v_23: G = __loaded[14];
+            let __v_24: G = __loaded[15];
+            let __v_25: G = __loaded[16];
+            let __v_26: G = __loaded[17];
+            let __v_27: G = __loaded[18];
+            let __v_28: G = __loaded[19];
+            let __v_29: G = __loaded[20];
+            let __v_30: G = __loaded[21];
+            let __v_31: G = __loaded[22];
+            let __v_32: G = __loaded[23];
+            let __v_33: G = __loaded[24];
+            let __v_34: G = __loaded[25];
+            let __v_35: G = __loaded[26];
+            let __v_36: G = __loaded[27];
+            let __v_37: G = __loaded[28];
+            let __v_38: G = __loaded[29];
+            let __v_39: G = __loaded[30];
+            let __v_40: G = __loaded[31];
+            let __v_41: G = { let __values: [G; 33] = [__v_5, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_24] = [__v_41];
             record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -4771,84 +4936,83 @@ fn aiur_fn_24(
         let __v_88: G = __r_arr[61];
         let __v_89: G = __r_arr[62];
         let __v_90: G = __r_arr[63];
-        let __v_91: G = G::from_u64(0);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_92: G = __loaded[0];
-        let __v_93: G = __loaded[1];
-        let __v_94: G = __loaded[2];
-        let __v_95: G = __loaded[3];
-        let __v_96: G = __loaded[4];
-        let __v_97: G = __loaded[5];
-        let __v_98: G = __loaded[6];
-        let __v_99: G = __loaded[7];
-        let __v_100: G = __loaded[8];
-        let __v_101: G = __loaded[9];
-        let __v_102: G = __loaded[10];
-        let __v_103: G = __loaded[11];
-        let __v_104: G = __loaded[12];
-        let __v_105: G = __loaded[13];
-        let __v_106: G = __loaded[14];
-        let __v_107: G = __loaded[15];
-        let __v_108: G = __loaded[16];
-        let __v_109: G = __loaded[17];
-        let __v_110: G = __loaded[18];
-        let __v_111: G = __loaded[19];
-        let __v_112: G = __loaded[20];
-        let __v_113: G = __loaded[21];
-        let __v_114: G = __loaded[22];
-        let __v_115: G = __loaded[23];
-        let __v_116: G = __loaded[24];
-        let __v_117: G = __loaded[25];
-        let __v_118: G = __loaded[26];
-        let __v_119: G = __loaded[27];
-        let __v_120: G = __loaded[28];
-        let __v_121: G = __loaded[29];
-        let __v_122: G = __loaded[30];
-        let __v_123: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_124: G = __loaded[0];
-        let __v_125: G = __loaded[1];
-        let __v_126: G = __loaded[2];
-        let __v_127: G = __loaded[3];
-        let __v_128: G = __loaded[4];
-        let __v_129: G = __loaded[5];
-        let __v_130: G = __loaded[6];
-        let __v_131: G = __loaded[7];
-        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
-        let __v_132: G = __r_arr[0];
-        let __v_133: G = __r_arr[1];
-        let __v_134: G = __r_arr[2];
-        let __v_135: G = __r_arr[3];
-        let __v_136: G = __r_arr[4];
-        let __v_137: G = __r_arr[5];
-        let __v_138: G = __r_arr[6];
-        let __v_139: G = __r_arr[7];
-        let __v_140: G = __r_arr[8];
-        let __v_141: G = __r_arr[9];
-        let __v_142: G = __r_arr[10];
-        let __v_143: G = __r_arr[11];
-        let __v_144: G = __r_arr[12];
-        let __v_145: G = __r_arr[13];
-        let __v_146: G = __r_arr[14];
-        let __v_147: G = __r_arr[15];
-        let __v_148: G = __r_arr[16];
-        let __v_149: G = __r_arr[17];
-        let __v_150: G = __r_arr[18];
-        let __v_151: G = __r_arr[19];
-        let __v_152: G = __r_arr[20];
-        let __v_153: G = __r_arr[21];
-        let __v_154: G = __r_arr[22];
-        let __v_155: G = __r_arr[23];
-        let __v_156: G = __r_arr[24];
-        let __v_157: G = __r_arr[25];
-        let __v_158: G = __r_arr[26];
-        let __v_159: G = __r_arr[27];
-        let __v_160: G = __r_arr[28];
-        let __v_161: G = __r_arr[29];
-        let __v_162: G = __r_arr[30];
-        let __v_163: G = __r_arr[31];
-        let __v_164: G = { let __values: [G; 34] = [__v_91, __v_5, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_24] = [__v_164];
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_91: G = __loaded[0];
+        let __v_92: G = __loaded[1];
+        let __v_93: G = __loaded[2];
+        let __v_94: G = __loaded[3];
+        let __v_95: G = __loaded[4];
+        let __v_96: G = __loaded[5];
+        let __v_97: G = __loaded[6];
+        let __v_98: G = __loaded[7];
+        let __v_99: G = __loaded[8];
+        let __v_100: G = __loaded[9];
+        let __v_101: G = __loaded[10];
+        let __v_102: G = __loaded[11];
+        let __v_103: G = __loaded[12];
+        let __v_104: G = __loaded[13];
+        let __v_105: G = __loaded[14];
+        let __v_106: G = __loaded[15];
+        let __v_107: G = __loaded[16];
+        let __v_108: G = __loaded[17];
+        let __v_109: G = __loaded[18];
+        let __v_110: G = __loaded[19];
+        let __v_111: G = __loaded[20];
+        let __v_112: G = __loaded[21];
+        let __v_113: G = __loaded[22];
+        let __v_114: G = __loaded[23];
+        let __v_115: G = __loaded[24];
+        let __v_116: G = __loaded[25];
+        let __v_117: G = __loaded[26];
+        let __v_118: G = __loaded[27];
+        let __v_119: G = __loaded[28];
+        let __v_120: G = __loaded[29];
+        let __v_121: G = __loaded[30];
+        let __v_122: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_123: G = __loaded[0];
+        let __v_124: G = __loaded[1];
+        let __v_125: G = __loaded[2];
+        let __v_126: G = __loaded[3];
+        let __v_127: G = __loaded[4];
+        let __v_128: G = __loaded[5];
+        let __v_129: G = __loaded[6];
+        let __v_130: G = __loaded[7];
+        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__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_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __v_131: G = __r_arr[0];
+        let __v_132: G = __r_arr[1];
+        let __v_133: G = __r_arr[2];
+        let __v_134: G = __r_arr[3];
+        let __v_135: G = __r_arr[4];
+        let __v_136: G = __r_arr[5];
+        let __v_137: G = __r_arr[6];
+        let __v_138: G = __r_arr[7];
+        let __v_139: G = __r_arr[8];
+        let __v_140: G = __r_arr[9];
+        let __v_141: G = __r_arr[10];
+        let __v_142: G = __r_arr[11];
+        let __v_143: G = __r_arr[12];
+        let __v_144: G = __r_arr[13];
+        let __v_145: G = __r_arr[14];
+        let __v_146: G = __r_arr[15];
+        let __v_147: G = __r_arr[16];
+        let __v_148: G = __r_arr[17];
+        let __v_149: G = __r_arr[18];
+        let __v_150: G = __r_arr[19];
+        let __v_151: G = __r_arr[20];
+        let __v_152: G = __r_arr[21];
+        let __v_153: G = __r_arr[22];
+        let __v_154: G = __r_arr[23];
+        let __v_155: G = __r_arr[24];
+        let __v_156: G = __r_arr[25];
+        let __v_157: G = __r_arr[26];
+        let __v_158: G = __r_arr[27];
+        let __v_159: G = __r_arr[28];
+        let __v_160: G = __r_arr[29];
+        let __v_161: G = __r_arr[30];
+        let __v_162: G = __r_arr[31];
+        let __v_163: G = { let __values: [G; 33] = [__v_5, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_24] = [__v_163];
         record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -4942,9 +5106,9 @@ fn aiur_fn_25(
     let __v_72: G = __r_arr[63];
     match __v_2.as_canonical_u64() {
       1023u64 => {
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_74: G = __loaded[0];
         let __v_75: G = __loaded[1];
         let __v_76: G = __loaded[2];
@@ -4990,122 +5154,119 @@ fn aiur_fn_25(
         let __v_115: G = G::from_u64(205);
         let __v_116: G = G::from_u64(224);
         let __v_117: G = G::from_u64(91);
-        let __v_118: G = G::from_u64(0);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_119: G = __loaded[0];
-        let __v_120: G = __loaded[1];
-        let __v_121: G = __loaded[2];
-        let __v_122: G = __loaded[3];
-        let __v_123: G = __loaded[4];
-        let __v_124: G = __loaded[5];
-        let __v_125: G = __loaded[6];
-        let __v_126: G = __loaded[7];
-        let __v_127: G = __loaded[8];
-        let __v_128: G = __loaded[9];
-        let __v_129: G = __loaded[10];
-        let __v_130: G = __loaded[11];
-        let __v_131: G = __loaded[12];
-        let __v_132: G = __loaded[13];
-        let __v_133: G = __loaded[14];
-        let __v_134: G = __loaded[15];
-        let __v_135: G = __loaded[16];
-        let __v_136: G = __loaded[17];
-        let __v_137: G = __loaded[18];
-        let __v_138: G = __loaded[19];
-        let __v_139: G = __loaded[20];
-        let __v_140: G = __loaded[21];
-        let __v_141: G = __loaded[22];
-        let __v_142: G = __loaded[23];
-        let __v_143: G = __loaded[24];
-        let __v_144: G = __loaded[25];
-        let __v_145: G = __loaded[26];
-        let __v_146: G = __loaded[27];
-        let __v_147: G = __loaded[28];
-        let __v_148: G = __loaded[29];
-        let __v_149: G = __loaded[30];
-        let __v_150: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_151: G = __loaded[0];
-        let __v_152: G = __loaded[1];
-        let __v_153: G = __loaded[2];
-        let __v_154: G = __loaded[3];
-        let __v_155: G = __loaded[4];
-        let __v_156: G = __loaded[5];
-        let __v_157: G = __loaded[6];
-        let __v_158: G = __loaded[7];
-        let __v_159: G = G::from_u64(64);
-        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
-        let __v_160: G = __r_arr[0];
-        let __v_161: G = __r_arr[1];
-        let __v_162: G = __r_arr[2];
-        let __v_163: G = __r_arr[3];
-        let __v_164: G = __r_arr[4];
-        let __v_165: G = __r_arr[5];
-        let __v_166: G = __r_arr[6];
-        let __v_167: G = __r_arr[7];
-        let __v_168: G = __r_arr[8];
-        let __v_169: G = __r_arr[9];
-        let __v_170: G = __r_arr[10];
-        let __v_171: G = __r_arr[11];
-        let __v_172: G = __r_arr[12];
-        let __v_173: G = __r_arr[13];
-        let __v_174: G = __r_arr[14];
-        let __v_175: G = __r_arr[15];
-        let __v_176: G = __r_arr[16];
-        let __v_177: G = __r_arr[17];
-        let __v_178: G = __r_arr[18];
-        let __v_179: G = __r_arr[19];
-        let __v_180: G = __r_arr[20];
-        let __v_181: G = __r_arr[21];
-        let __v_182: G = __r_arr[22];
-        let __v_183: G = __r_arr[23];
-        let __v_184: G = __r_arr[24];
-        let __v_185: G = __r_arr[25];
-        let __v_186: G = __r_arr[26];
-        let __v_187: G = __r_arr[27];
-        let __v_188: G = __r_arr[28];
-        let __v_189: G = __r_arr[29];
-        let __v_190: G = __r_arr[30];
-        let __v_191: G = __r_arr[31];
-        let __v_192: G = { let __values: [G; 34] = [__v_118, __v_5, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_193: G = G::from_u64(1);
-        let __v_194: G = G::from_u64(1);
-        let __v_195: G = { let __values: [G; 3] = [__v_193, __v_194, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_196: G = G::from_u64(0);
-        let __v_197: G = G::from_u64(0);
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_198: G = __loaded[0];
-        let __v_199: G = __loaded[1];
-        let __v_200: G = __loaded[2];
-        let __v_201: G = __loaded[3];
-        let __v_202: G = __loaded[4];
-        let __v_203: G = __loaded[5];
-        let __v_204: G = __loaded[6];
-        let __v_205: G = __loaded[7];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_206: G = __r_arr[0];
-        let __v_207: G = __r_arr[1];
-        let __v_208: G = __r_arr[2];
-        let __v_209: G = __r_arr[3];
-        let __v_210: G = __r_arr[4];
-        let __v_211: G = __r_arr[5];
-        let __v_212: G = __r_arr[6];
-        let __v_213: G = __r_arr[7];
-        let __v_214: G = { let __values: [G; 8] = [__v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_215: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
-        let __v_216: G = __r_arr[0];
-        let __ret: [G; OUT_25] = [__v_216];
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_118: G = __loaded[0];
+        let __v_119: G = __loaded[1];
+        let __v_120: G = __loaded[2];
+        let __v_121: G = __loaded[3];
+        let __v_122: G = __loaded[4];
+        let __v_123: G = __loaded[5];
+        let __v_124: G = __loaded[6];
+        let __v_125: G = __loaded[7];
+        let __v_126: G = __loaded[8];
+        let __v_127: G = __loaded[9];
+        let __v_128: G = __loaded[10];
+        let __v_129: G = __loaded[11];
+        let __v_130: G = __loaded[12];
+        let __v_131: G = __loaded[13];
+        let __v_132: G = __loaded[14];
+        let __v_133: G = __loaded[15];
+        let __v_134: G = __loaded[16];
+        let __v_135: G = __loaded[17];
+        let __v_136: G = __loaded[18];
+        let __v_137: G = __loaded[19];
+        let __v_138: G = __loaded[20];
+        let __v_139: G = __loaded[21];
+        let __v_140: G = __loaded[22];
+        let __v_141: G = __loaded[23];
+        let __v_142: G = __loaded[24];
+        let __v_143: G = __loaded[25];
+        let __v_144: G = __loaded[26];
+        let __v_145: G = __loaded[27];
+        let __v_146: G = __loaded[28];
+        let __v_147: G = __loaded[29];
+        let __v_148: G = __loaded[30];
+        let __v_149: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_150: G = __loaded[0];
+        let __v_151: G = __loaded[1];
+        let __v_152: G = __loaded[2];
+        let __v_153: G = __loaded[3];
+        let __v_154: G = __loaded[4];
+        let __v_155: G = __loaded[5];
+        let __v_156: G = __loaded[6];
+        let __v_157: G = __loaded[7];
+        let __v_158: G = G::from_u64(64);
+        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __v_159: G = __r_arr[0];
+        let __v_160: G = __r_arr[1];
+        let __v_161: G = __r_arr[2];
+        let __v_162: G = __r_arr[3];
+        let __v_163: G = __r_arr[4];
+        let __v_164: G = __r_arr[5];
+        let __v_165: G = __r_arr[6];
+        let __v_166: G = __r_arr[7];
+        let __v_167: G = __r_arr[8];
+        let __v_168: G = __r_arr[9];
+        let __v_169: G = __r_arr[10];
+        let __v_170: G = __r_arr[11];
+        let __v_171: G = __r_arr[12];
+        let __v_172: G = __r_arr[13];
+        let __v_173: G = __r_arr[14];
+        let __v_174: G = __r_arr[15];
+        let __v_175: G = __r_arr[16];
+        let __v_176: G = __r_arr[17];
+        let __v_177: G = __r_arr[18];
+        let __v_178: G = __r_arr[19];
+        let __v_179: G = __r_arr[20];
+        let __v_180: G = __r_arr[21];
+        let __v_181: G = __r_arr[22];
+        let __v_182: G = __r_arr[23];
+        let __v_183: G = __r_arr[24];
+        let __v_184: G = __r_arr[25];
+        let __v_185: G = __r_arr[26];
+        let __v_186: G = __r_arr[27];
+        let __v_187: G = __r_arr[28];
+        let __v_188: G = __r_arr[29];
+        let __v_189: G = __r_arr[30];
+        let __v_190: G = __r_arr[31];
+        let __v_191: G = { let __values: [G; 33] = [__v_5, __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]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_192: G = G::from_u64(0);
+        let __v_193: G = G::from_u64(0);
+        let __v_194: G = G::from_u64(0);
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_195: G = __loaded[0];
+        let __v_196: G = __loaded[1];
+        let __v_197: G = __loaded[2];
+        let __v_198: G = __loaded[3];
+        let __v_199: G = __loaded[4];
+        let __v_200: G = __loaded[5];
+        let __v_201: G = __loaded[6];
+        let __v_202: G = __loaded[7];
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202]; 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_203: G = __r_arr[0];
+        let __v_204: G = __r_arr[1];
+        let __v_205: G = __r_arr[2];
+        let __v_206: G = __r_arr[3];
+        let __v_207: G = __r_arr[4];
+        let __v_208: G = __r_arr[5];
+        let __v_209: G = __r_arr[6];
+        let __v_210: G = __r_arr[7];
+        let __v_211: G = { let __values: [G; 8] = [__v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_212: 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_192, __v_193, __v_194, __v_211, __v_212, __v_191]; 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_213: G = __r_arr[0];
+        let __ret: [G; OUT_25] = [__v_213];
         record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __v_73: G = __r_arr[0];
         let __v_74: G = (__v_73 * __v_7);
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 __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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_76: G = __loaded[0];
         let __v_77: G = __loaded[1];
         let __v_78: G = __loaded[2];
@@ -5124,7 +5285,7 @@ fn aiur_fn_25(
         let __v_90: G = (__v_89 * __v_6);
         let __v_91: G = (__v_86 + __v_90);
         let __v_92: G = (__v_74 + __v_91);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
         let __v_93: G = __loaded[0];
         let __v_94: G = __loaded[1];
         let __v_95: G = __loaded[2];
@@ -5157,7 +5318,7 @@ fn aiur_fn_25(
         let __v_122: G = __loaded[29];
         let __v_123: G = __loaded[30];
         let __v_124: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_125: G = __loaded[0];
         let __v_126: G = __loaded[1];
         let __v_127: G = __loaded[2];
@@ -5200,16 +5361,14 @@ fn aiur_fn_25(
         let __v_163: G = __r_arr[29];
         let __v_164: G = __r_arr[30];
         let __v_165: G = __r_arr[31];
-        let __v_166: G = G::from_u64(1);
-        let __v_167: G = G::from_u64(1);
-        let __v_168: G = { let __values: [G; 3] = [__v_166, __v_167, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_169: G = G::from_u64(0);
-        let __v_170: G = G::from_u64(1);
-        let __v_171: G = (__v_2 + __v_170);
-        let __v_172: G = { let __values: [G; 32] = [__v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
-        let __v_173: G = __r_arr[0];
-        let __ret: [G; OUT_25] = [__v_173];
+        let __v_166: G = G::from_u64(0);
+        let __v_167: G = G::from_u64(0);
+        let __v_168: G = G::from_u64(1);
+        let __v_169: G = (__v_2 + __v_168);
+        let __v_170: 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_166, __v_167, __v_169, __v_3, __v_170, __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_171: G = __r_arr[0];
+        let __ret: [G; OUT_25] = [__v_171];
         record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8135,7 +8294,7 @@ fn aiur_fn_29(
         return Ok(__ret);
       },
       4u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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];
@@ -8239,7 +8398,7 @@ fn aiur_fn_29(
         return Ok(__ret);
       },
       10u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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];
@@ -8258,7 +8417,7 @@ fn aiur_fn_29(
         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_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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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];
@@ -8277,7 +8436,7 @@ fn aiur_fn_29(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_55: G = __loaded[0];
         let __v_56: G = __loaded[1];
         let __v_57: G = __loaded[2];
@@ -8352,13 +8511,12 @@ fn aiur_fn_30(
       },
       _ => {
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = (__v_8 - __v_12);
-        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_30] = [__v_15];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = (__v_8 - __v_11);
+        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_12, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __v_14: G = { let __values: [G; 2] = [__v_0, __v_13]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_30] = [__v_14];
         record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8393,9 +8551,8 @@ fn aiur_fn_31(
       1u64 => {
         match __v_11.as_canonical_u64() {
           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_31] = [__v_13];
+            let __v_12: G = { let __values: [G; 2] = [__v_0, __v_8]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_31] = [__v_12];
             record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -8404,11 +8561,10 @@ fn aiur_fn_31(
             let __v_13: G = G::from_u64(1);
             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_30] = { let __args: [G; IN_30] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_31] = [__v_18];
+            let __v_16: G = __r_arr[0];
+            let __v_17: G = { let __values: [G; 2] = [__v_15, __v_16]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_31] = [__v_17];
             record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -8419,11 +8575,10 @@ fn aiur_fn_31(
         let __v_13: G = G::from_u64(1);
         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_30] = { let __args: [G; IN_30] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_31] = [__v_18];
+        let __v_16: G = __r_arr[0];
+        let __v_17: G = { let __values: [G; 2] = [__v_15, __v_16]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_31] = [__v_17];
         record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8462,9 +8617,8 @@ fn aiur_fn_32(
             let __v_13: G = G::from_u64(64);
             let __v_14: G = (__v_0 * __v_13);
             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_32] = [__v_17];
+            let __v_16: G = { let __values: [G; 2] = [__v_15, __v_9]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_32] = [__v_16];
             record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -8476,11 +8630,10 @@ fn aiur_fn_32(
             let __v_17: G = (__v_10 - __v_16);
             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_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_32] = [__v_22];
+            let __v_20: G = __r_arr[0];
+            let __v_21: G = { let __values: [G; 2] = [__v_19, __v_20]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_32] = [__v_21];
             record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -8494,11 +8647,10 @@ fn aiur_fn_32(
         let __v_17: G = (__v_10 - __v_16);
         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_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
-        let __v_21: G = __r_arr[0];
-        let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_32] = [__v_22];
+        let __v_20: G = __r_arr[0];
+        let __v_21: G = { let __values: [G; 2] = [__v_19, __v_20]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_32] = [__v_21];
         record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8537,9 +8689,8 @@ fn aiur_fn_33(
             let __v_13: G = G::from_u64(16);
             let __v_14: G = (__v_0 * __v_13);
             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_33] = [__v_17];
+            let __v_16: G = { let __values: [G; 2] = [__v_15, __v_9]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_33] = [__v_16];
             record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -8551,11 +8702,10 @@ fn aiur_fn_33(
             let __v_17: G = (__v_10 - __v_16);
             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_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_33] = [__v_22];
+            let __v_20: G = __r_arr[0];
+            let __v_21: G = { let __values: [G; 2] = [__v_19, __v_20]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_33] = [__v_21];
             record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -8569,11 +8719,10 @@ fn aiur_fn_33(
         let __v_17: G = (__v_10 - __v_16);
         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_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
-        let __v_21: G = __r_arr[0];
-        let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_33] = [__v_22];
+        let __v_20: G = __r_arr[0];
+        let __v_21: G = { let __values: [G; 2] = [__v_19, __v_20]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_33] = [__v_21];
         record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8593,35 +8742,31 @@ fn aiur_fn_34(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_34] = [__v_1];
         record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+      _ => {
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; 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_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_34] = [__v_13];
+        let __ret: [G; OUT_34] = [__v_12];
         record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -8656,7 +8801,7 @@ fn aiur_fn_35(
     let __v_17: G = inp[17];
     match __v_0.as_canonical_u64() {
       7u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_18: G = __loaded[0];
         let __v_19: G = __loaded[1];
         let __v_20: G = __loaded[2];
@@ -8744,7 +8889,7 @@ fn aiur_fn_36(
     let __v_17: G = inp[17];
     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_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_18: G = __loaded[0];
         let __v_19: G = __loaded[1];
         let __v_20: G = __loaded[2];
@@ -8832,7 +8977,7 @@ fn aiur_fn_37(
     let __v_17: G = inp[17];
     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_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_18: G = __loaded[0];
         let __v_19: G = __loaded[1];
         let __v_20: G = __loaded[2];
@@ -8921,7 +9066,7 @@ fn aiur_fn_38(
     let __v_18: G = inp[18];
     match __v_0.as_canonical_u64() {
       7u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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];
@@ -8940,7 +9085,7 @@ fn aiur_fn_38(
         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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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];
@@ -9009,7 +9154,7 @@ fn aiur_fn_39(
     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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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];
@@ -9028,7 +9173,7 @@ fn aiur_fn_39(
         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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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];
@@ -9097,7 +9242,7 @@ fn aiur_fn_40(
     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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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];
@@ -9116,7 +9261,7 @@ fn aiur_fn_40(
         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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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];
@@ -9166,7 +9311,7 @@ fn aiur_fn_41(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -9199,71 +9344,39 @@ fn aiur_fn_41(
     let __v_31: G = __loaded[29];
     let __v_32: G = __loaded[30];
     let __v_33: G = __loaded[31];
-    let __v_34: G = G::from_u64(0);
-    let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_36: G = G::from_u64(0);
-    let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_38: G = G::from_u64(0);
-    let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_40: G = G::from_u64(0);
-    let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_42: G = G::from_u64(0);
-    let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_44: G = G::from_u64(0);
-    let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_46: G = G::from_u64(0);
-    let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_48: G = G::from_u64(0);
-    let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __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_50: G = G::from_u64(0);
-    let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_52: G = G::from_u64(0);
-    let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_54: G = G::from_u64(0);
-    let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_56: G = G::from_u64(0);
-    let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __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 __v_58: G = G::from_u64(0);
-    let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_60: G = G::from_u64(0);
-    let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __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 __v_62: G = G::from_u64(0);
-    let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __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 __v_64: G = G::from_u64(0);
-    let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __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_66: G = G::from_u64(0);
-    let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __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_68: G = G::from_u64(0);
-    let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __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_70: G = G::from_u64(0);
-    let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_72: G = G::from_u64(0);
-    let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_74: G = G::from_u64(0);
-    let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_76: G = G::from_u64(0);
-    let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_78: G = G::from_u64(0);
-    let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_80: G = G::from_u64(0);
-    let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_82: G = G::from_u64(0);
-    let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_84: G = G::from_u64(0);
-    let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_86: G = G::from_u64(0);
-    let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_88: G = G::from_u64(0);
-    let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_90: G = G::from_u64(0);
-    let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_92: G = G::from_u64(0);
-    let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_94: G = G::from_u64(0);
-    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_41] = [__v_97];
+    let __v_34: G = { let __values: [G; 2] = [__v_33, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_35: G = { let __values: [G; 2] = [__v_32, __v_34]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_36: G = { let __values: [G; 2] = [__v_31, __v_35]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_37: G = { let __values: [G; 2] = [__v_30, __v_36]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_38: G = { let __values: [G; 2] = [__v_29, __v_37]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_39: G = { let __values: [G; 2] = [__v_28, __v_38]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_40: G = { let __values: [G; 2] = [__v_27, __v_39]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_41: G = { let __values: [G; 2] = [__v_26, __v_40]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_42: G = { let __values: [G; 2] = [__v_25, __v_41]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_43: G = { let __values: [G; 2] = [__v_24, __v_42]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_44: G = { let __values: [G; 2] = [__v_23, __v_43]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_45: G = { let __values: [G; 2] = [__v_22, __v_44]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_46: G = { let __values: [G; 2] = [__v_21, __v_45]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_47: G = { let __values: [G; 2] = [__v_20, __v_46]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_48: G = { let __values: [G; 2] = [__v_19, __v_47]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_49: G = { let __values: [G; 2] = [__v_18, __v_48]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_50: G = { let __values: [G; 2] = [__v_17, __v_49]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_51: G = { let __values: [G; 2] = [__v_16, __v_50]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_52: G = { let __values: [G; 2] = [__v_15, __v_51]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_53: G = { let __values: [G; 2] = [__v_14, __v_52]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_54: G = { let __values: [G; 2] = [__v_13, __v_53]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_55: G = { let __values: [G; 2] = [__v_12, __v_54]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_56: G = { let __values: [G; 2] = [__v_11, __v_55]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_57: G = { let __values: [G; 2] = [__v_10, __v_56]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_58: G = { let __values: [G; 2] = [__v_9, __v_57]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_59: G = { let __values: [G; 2] = [__v_8, __v_58]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_60: G = { let __values: [G; 2] = [__v_7, __v_59]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_61: G = { let __values: [G; 2] = [__v_6, __v_60]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_62: G = { let __values: [G; 2] = [__v_5, __v_61]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_63: G = { let __values: [G; 2] = [__v_4, __v_62]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_64: G = { let __values: [G; 2] = [__v_3, __v_63]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_65: G = { let __values: [G; 2] = [__v_2, __v_64]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_41] = [__v_65];
     record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -9385,7 +9498,7 @@ fn aiur_fn_43(
     let __v_8: G = inp[8];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -9455,7 +9568,7 @@ fn aiur_fn_44(
     let __v_8: G = inp[8];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -9511,9 +9624,8 @@ fn aiur_fn_45(
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_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_45] = [__v_12];
+        let __v_11: G = { let __values: [G; 2] = [__v_10, __v_9]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_45] = [__v_11];
         record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -9547,7 +9659,7 @@ fn aiur_fn_45(
         return Ok(__ret);
       },
       2u64 => {
-        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
@@ -9557,7 +9669,7 @@ fn aiur_fn_45(
         let __v_16: G = __loaded[6];
         let __v_17: G = __loaded[7];
         let __v_18: G = __loaded[8];
-        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
         let __v_19: G = __loaded[0];
         let __v_20: G = __loaded[1];
         let __v_21: G = __loaded[2];
@@ -9587,7 +9699,7 @@ fn aiur_fn_45(
         return Ok(__ret);
       },
       3u64 => {
-        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
@@ -9597,7 +9709,7 @@ fn aiur_fn_45(
         let __v_16: G = __loaded[6];
         let __v_17: G = __loaded[7];
         let __v_18: G = __loaded[8];
-        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
         let __v_19: G = __loaded[0];
         let __v_20: G = __loaded[1];
         let __v_21: G = __loaded[2];
@@ -9653,47 +9765,43 @@ fn aiur_fn_46(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_46] = [__v_1];
         record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        let __v_8: G = __loaded[3];
-        let __v_9: G = __loaded[4];
-        let __v_10: G = __loaded[5];
-        let __v_11: G = __loaded[6];
-        let __v_12: G = __loaded[7];
-        let __v_13: G = __loaded[8];
-        let __v_14: G = __loaded[9];
-        let __v_15: G = __loaded[10];
-        let __v_16: G = __loaded[11];
-        let __v_17: G = __loaded[12];
-        let __v_18: G = __loaded[13];
-        let __v_19: G = __loaded[14];
-        let __v_20: G = __loaded[15];
-        let __v_21: G = __loaded[16];
-        let __v_22: G = __loaded[17];
-        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        let __v_8: G = __loaded[4];
+        let __v_9: G = __loaded[5];
+        let __v_10: G = __loaded[6];
+        let __v_11: G = __loaded[7];
+        let __v_12: G = __loaded[8];
+        let __v_13: G = __loaded[9];
+        let __v_14: G = __loaded[10];
+        let __v_15: G = __loaded[11];
+        let __v_16: G = __loaded[12];
+        let __v_17: G = __loaded[13];
+        let __v_18: G = __loaded[14];
+        let __v_19: G = __loaded[15];
+        let __v_20: G = __loaded[16];
+        let __v_21: G = __loaded[17];
+        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+        let __v_22: G = __r_arr[0];
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __ret: [G; OUT_46] = [__v_24];
+        let __ret: [G; OUT_46] = [__v_23];
         record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -9710,38 +9818,34 @@ fn aiur_fn_47(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_47] = [__v_1];
         record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        let __v_8: G = __loaded[3];
-        let __v_9: G = __loaded[4];
-        let __v_10: G = __loaded[5];
-        let __v_11: G = __loaded[6];
-        let __v_12: G = __loaded[7];
-        let __v_13: G = __loaded[8];
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } else { aiur_fn_47(__args, record, io_buffer, __cu)? } };
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        let __v_8: G = __loaded[4];
+        let __v_9: G = __loaded[5];
+        let __v_10: G = __loaded[6];
+        let __v_11: G = __loaded[7];
+        let __v_12: G = __loaded[8];
+        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } else { aiur_fn_47(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_47] = [__v_15];
+        let __ret: [G; OUT_47] = [__v_14];
         record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -9758,28 +9862,24 @@ fn aiur_fn_48(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_48] = [__v_1];
         record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_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 __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_3, __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_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_48] = [__v_6];
+        let __ret: [G; OUT_48] = [__v_5];
         record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -9799,33 +9899,29 @@ fn aiur_fn_49(
     match __v_0.as_canonical_u64() {
       0u64 => {
         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_49] = [__v_4];
+        let __v_3: G = { let __values: [G; 2] = [__v_2, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_49] = [__v_3];
         record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __v_2: G = G::from_u64(0);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_49] = [__v_4];
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = { let __values: [G; 2] = [__v_2, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_49] = [__v_3];
         record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __v_2: G = G::from_u64(0);
-        let __v_3: G = G::from_u64(2);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_49] = [__v_4];
+        let __v_2: G = G::from_u64(2);
+        let __v_3: G = { let __values: [G; 2] = [__v_2, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_49] = [__v_3];
         record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __v_2: G = G::from_u64(0);
-        let __v_3: G = G::from_u64(3);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_49] = [__v_4];
+        let __v_2: G = G::from_u64(3);
+        let __v_3: G = { let __values: [G; 2] = [__v_2, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_49] = [__v_3];
         record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -9861,7 +9957,7 @@ fn aiur_fn_50(
     let __v_12: G = inp[12];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_13: G = __loaded[0];
         let __v_14: G = __loaded[1];
         let __v_15: G = __loaded[2];
@@ -9880,7 +9976,7 @@ fn aiur_fn_50(
         let __v_28: G = __loaded[15];
         let __v_29: G = __loaded[16];
         let __v_30: G = __loaded[17];
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_31: G = __loaded[0];
         let __v_32: G = __loaded[1];
         let __v_33: G = __loaded[2];
@@ -9901,15 +9997,14 @@ fn aiur_fn_50(
         let __v_48: G = __loaded[17];
         let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
         let __v_49: G = __r_arr[0];
-        let __v_50: G = G::from_u64(0);
         let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __v_50: G = __r_arr[0];
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_51: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_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 __v_52: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
-        let __v_53: G = __r_arr[0];
-        let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_50] = [__v_54];
+        let __v_53: G = { let __values: [G; 2] = [__v_49, __v_52]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_50] = [__v_53];
         record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -9939,7 +10034,7 @@ fn aiur_fn_51(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_10: G = __loaded[0];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
@@ -9982,36 +10077,32 @@ fn aiur_fn_52(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    let __v_12: G = __loaded[10];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_52] = [__v_1];
         record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } else { aiur_fn_52(__args, record, io_buffer, __cu)? } };
+      _ => {
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __v_11: G = __loaded[9];
+        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_11, __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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__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[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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } else { aiur_fn_51(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_52] = [__v_14];
+        let __ret: [G; OUT_52] = [__v_13];
         record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -10073,7 +10164,7 @@ fn aiur_fn_53(
     let __v_44: G = inp[44];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_45: G = __loaded[0];
         let __v_46: G = __loaded[1];
         let __v_47: G = __loaded[2];
@@ -10095,7 +10186,7 @@ fn aiur_fn_53(
         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_730] = { let __args: [G; IN_730] = [__v_43]; 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_731] = { let __args: [G; IN_731] = [__v_43]; 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_66: G = __r_arr[0];
         let __v_67: G = __r_arr[1];
         let __v_68: G = __r_arr[2];
@@ -10104,25 +10195,24 @@ fn aiur_fn_53(
         let __v_71: G = __r_arr[5];
         let __v_72: G = __r_arr[6];
         let __v_73: G = __r_arr[7];
-        let __v_74: G = G::from_u64(0);
         let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } else { aiur_fn_52(__args, record, io_buffer, __cu)? } };
+        let __v_74: G = __r_arr[0];
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_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 __v_75: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_76: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
         let __v_77: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
         let __v_78: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
         let __v_79: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __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_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
         let __v_80: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
         let __v_81: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
-        let __v_82: G = __r_arr[0];
-        let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_53] = [__v_83];
+        let __v_82: G = { let __values: [G; 2] = [__v_65, __v_81]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_53] = [__v_82];
         record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -10153,7 +10243,7 @@ fn aiur_fn_54(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_11: G = __loaded[0];
         let __v_12: G = __loaded[1];
         let __v_13: G = __loaded[2];
@@ -10172,13 +10262,12 @@ fn aiur_fn_54(
         let __v_26: G = __loaded[15];
         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_29] = { let __args: [G; IN_29] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __v_29: G = __r_arr[0];
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
         let __v_30: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
-        let __v_31: G = __r_arr[0];
-        let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_54] = [__v_32];
+        let __v_31: G = { let __values: [G; 2] = [__v_0, __v_30]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_54] = [__v_31];
         record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -10209,7 +10298,7 @@ fn aiur_fn_55(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_11: G = __loaded[0];
         let __v_12: G = __loaded[1];
         let __v_13: G = __loaded[2];
@@ -10289,7 +10378,7 @@ fn aiur_fn_56(
     let __v_34: G = inp[34];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_35: G = __loaded[0];
         let __v_36: G = __loaded[1];
         let __v_37: G = __loaded[2];
@@ -10308,19 +10397,18 @@ fn aiur_fn_56(
         let __v_50: G = __loaded[15];
         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_29] = { let __args: [G; IN_29] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __v_53: G = __r_arr[0];
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_53]; 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_54: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
         let __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __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_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
         let __v_57: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
-        let __v_58: G = __r_arr[0];
-        let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_56] = [__v_59];
+        let __v_58: G = { let __values: [G; 2] = [__v_0, __v_57]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_56] = [__v_58];
         record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -10340,61 +10428,57 @@ fn aiur_fn_57(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: G = __loaded[31];
-    let __v_34: G = __loaded[32];
-    let __v_35: G = __loaded[33];
-    let __v_36: G = __loaded[34];
-    let __v_37: G = __loaded[35];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_57] = [__v_1];
         record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_37, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } else { aiur_fn_57(__args, record, io_buffer, __cu)? } };
+      _ => {
+        let __loaded: [G; 35] = { let __mq = record.memory_queries.get_mut(&35).ok_or(ExecError::InvalidMemorySize(35))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 35 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 35] = __args[..35].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __v_11: G = __loaded[9];
+        let __v_12: G = __loaded[10];
+        let __v_13: G = __loaded[11];
+        let __v_14: G = __loaded[12];
+        let __v_15: G = __loaded[13];
+        let __v_16: G = __loaded[14];
+        let __v_17: G = __loaded[15];
+        let __v_18: G = __loaded[16];
+        let __v_19: G = __loaded[17];
+        let __v_20: G = __loaded[18];
+        let __v_21: G = __loaded[19];
+        let __v_22: G = __loaded[20];
+        let __v_23: G = __loaded[21];
+        let __v_24: G = __loaded[22];
+        let __v_25: G = __loaded[23];
+        let __v_26: G = __loaded[24];
+        let __v_27: G = __loaded[25];
+        let __v_28: G = __loaded[26];
+        let __v_29: G = __loaded[27];
+        let __v_30: G = __loaded[28];
+        let __v_31: G = __loaded[29];
+        let __v_32: G = __loaded[30];
+        let __v_33: G = __loaded[31];
+        let __v_34: G = __loaded[32];
+        let __v_35: G = __loaded[33];
+        let __v_36: G = __loaded[34];
+        let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_36, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } else { aiur_fn_57(__args, record, io_buffer, __cu)? } };
+        let __v_37: G = __r_arr[0];
+        let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_37]; 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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
-        let __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_57] = [__v_39];
+        let __ret: [G; OUT_57] = [__v_38];
         record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -10439,7 +10523,7 @@ fn aiur_fn_58(
     let __v_27: G = inp[27];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_28: G = __loaded[0];
         let __v_29: G = __loaded[1];
         let __v_30: G = __loaded[2];
@@ -10458,7 +10542,7 @@ fn aiur_fn_58(
         let __v_43: G = __loaded[15];
         let __v_44: G = __loaded[16];
         let __v_45: G = __loaded[17];
-        let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_26]; 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_726] = { let __args: [G; IN_726] = [__v_26]; 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_46: G = __r_arr[0];
         let __v_47: G = __r_arr[1];
         let __v_48: G = __r_arr[2];
@@ -10467,21 +10551,20 @@ fn aiur_fn_58(
         let __v_51: G = __r_arr[5];
         let __v_52: G = __r_arr[6];
         let __v_53: G = __r_arr[7];
-        let __v_54: G = G::from_u64(0);
         let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } else { aiur_fn_57(__args, record, io_buffer, __cu)? } };
+        let __v_54: G = __r_arr[0];
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
         let __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
         let __v_57: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
         let __v_58: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __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_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
         let __v_59: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
-        let __v_60: G = __r_arr[0];
-        let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_58] = [__v_61];
+        let __v_60: G = { let __values: [G; 2] = [__v_0, __v_59]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_58] = [__v_60];
         record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -10626,31 +10709,28 @@ fn aiur_fn_61(
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_46: G = G::from_u64(0);
-        let __v_47: G = G::from_u64(0);
         let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
-        let __v_48: G = __r_arr[0];
-        let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_61] = [__v_49];
+        let __v_47: G = __r_arr[0];
+        let __v_48: G = { let __values: [G; 2] = [__v_46, __v_47]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_61] = [__v_48];
         record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __v_46: G = G::from_u64(0);
-        let __v_47: G = G::from_u64(1);
+        let __v_46: G = G::from_u64(1);
         let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } else { aiur_fn_58(__args, record, io_buffer, __cu)? } };
-        let __v_48: G = __r_arr[0];
-        let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_61] = [__v_49];
+        let __v_47: G = __r_arr[0];
+        let __v_48: G = { let __values: [G; 2] = [__v_46, __v_47]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_61] = [__v_48];
         record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __v_46: G = G::from_u64(0);
-        let __v_47: G = G::from_u64(2);
+        let __v_46: G = G::from_u64(2);
         let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
-        let __v_48: G = __r_arr[0];
-        let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_61] = [__v_49];
+        let __v_47: G = __r_arr[0];
+        let __v_48: G = { let __values: [G; 2] = [__v_46, __v_47]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_61] = [__v_48];
         record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -10673,72 +10753,68 @@ fn aiur_fn_62(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: G = __loaded[31];
-    let __v_34: G = __loaded[32];
-    let __v_35: G = __loaded[33];
-    let __v_36: G = __loaded[34];
-    let __v_37: G = __loaded[35];
-    let __v_38: G = __loaded[36];
-    let __v_39: G = __loaded[37];
-    let __v_40: G = __loaded[38];
-    let __v_41: G = __loaded[39];
-    let __v_42: G = __loaded[40];
-    let __v_43: G = __loaded[41];
-    let __v_44: G = __loaded[42];
-    let __v_45: G = __loaded[43];
-    let __v_46: G = __loaded[44];
-    let __v_47: G = __loaded[45];
-    let __v_48: G = __loaded[46];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_62] = [__v_1];
         record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } else { aiur_fn_62(__args, record, io_buffer, __cu)? } };
+      _ => {
+        let __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __v_11: G = __loaded[9];
+        let __v_12: G = __loaded[10];
+        let __v_13: G = __loaded[11];
+        let __v_14: G = __loaded[12];
+        let __v_15: G = __loaded[13];
+        let __v_16: G = __loaded[14];
+        let __v_17: G = __loaded[15];
+        let __v_18: G = __loaded[16];
+        let __v_19: G = __loaded[17];
+        let __v_20: G = __loaded[18];
+        let __v_21: G = __loaded[19];
+        let __v_22: G = __loaded[20];
+        let __v_23: G = __loaded[21];
+        let __v_24: G = __loaded[22];
+        let __v_25: G = __loaded[23];
+        let __v_26: G = __loaded[24];
+        let __v_27: G = __loaded[25];
+        let __v_28: G = __loaded[26];
+        let __v_29: G = __loaded[27];
+        let __v_30: G = __loaded[28];
+        let __v_31: G = __loaded[29];
+        let __v_32: G = __loaded[30];
+        let __v_33: G = __loaded[31];
+        let __v_34: G = __loaded[32];
+        let __v_35: G = __loaded[33];
+        let __v_36: G = __loaded[34];
+        let __v_37: G = __loaded[35];
+        let __v_38: G = __loaded[36];
+        let __v_39: G = __loaded[37];
+        let __v_40: G = __loaded[38];
+        let __v_41: G = __loaded[39];
+        let __v_42: G = __loaded[40];
+        let __v_43: G = __loaded[41];
+        let __v_44: G = __loaded[42];
+        let __v_45: G = __loaded[43];
+        let __v_46: G = __loaded[44];
+        let __v_47: G = __loaded[45];
+        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_47, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } else { aiur_fn_62(__args, record, io_buffer, __cu)? } };
+        let __v_48: G = __r_arr[0];
+        let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_48]; 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_49: G = __r_arr[0];
-        let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } else { aiur_fn_61(__args, record, io_buffer, __cu)? } };
-        let __v_50: G = __r_arr[0];
-        let __ret: [G; OUT_62] = [__v_50];
+        let __ret: [G; OUT_62] = [__v_49];
         record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -10875,7 +10951,7 @@ fn aiur_fn_64(
   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_720] = { let __args: [G; IN_720] = [__v_0]; 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_722] = { let __args: [G; IN_722] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -10906,7 +10982,7 @@ fn aiur_fn_65(
   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_720] = { let __args: [G; IN_720] = [__v_0]; 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_722] = { let __args: [G; IN_722] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -10937,7 +11013,7 @@ fn aiur_fn_66(
   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_720] = { let __args: [G; IN_720] = [__v_0]; 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_722] = { let __args: [G; IN_722] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -11025,7 +11101,7 @@ fn aiur_fn_67(
         let __v_51: G = __r_arr[0];
         match __v_0.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_1]; 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_730] = { let __args: [G; IN_730] = [__v_1]; 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_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
             let __v_54: G = __r_arr[2];
@@ -11207,28 +11283,22 @@ fn aiur_fn_68(
 ) -> Result<[G; OUT_68], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_68] = [__v_2, __v_3];
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_68] = [__v_1, __v_2];
         record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      1u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_68] = [__v_4, __v_7];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __ret: [G; OUT_68] = [__v_1, __v_2];
         record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -11260,30 +11330,36 @@ fn aiur_fn_69(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_2: G = __loaded[0];
-        let __v_3: G = __loaded[1];
-        let __v_4: G = __loaded[2];
-        match __v_2.as_canonical_u64() {
+        match __v_0.as_canonical_u64() {
           0u64 => {
-            let __v_5: G = G::from_u64(1);
-            let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } else { aiur_fn_69(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __v_8: G = __r_arr[1];
-            let __v_9: G = __r_arr[2];
-            let __v_10: G = __r_arr[3];
-            let __v_11: G = __r_arr[4];
-            let __v_12: G = __r_arr[5];
-            let __v_13: G = __r_arr[6];
-            let __v_14: G = __r_arr[7];
-            let __v_15: G = __r_arr[8];
-            let __ret: [G; OUT_69] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15];
+            let __v_2: G = G::from_u64(0);
+            let __v_3: G = G::from_u64(1);
+            if (__v_2 != __v_3) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_69] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2];
             record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_2: G = __loaded[0];
+            let __v_3: G = __loaded[1];
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = (__v_1 - __v_4);
+            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __v_8: G = __r_arr[2];
+            let __v_9: G = __r_arr[3];
+            let __v_10: G = __r_arr[4];
+            let __v_11: G = __r_arr[5];
+            let __v_12: G = __r_arr[6];
+            let __v_13: G = __r_arr[7];
+            let __v_14: G = __r_arr[8];
+            let __ret: [G; OUT_69] = [__v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14];
+            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
@@ -11302,80 +11378,86 @@ fn aiur_fn_70(
 ) -> Result<[G; OUT_70], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_2); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_2, record) };
-        let __v_4: G = __b1_out[0];
-        let __v_5: G = __b1_out[1];
-        let __v_6: G = __b1_out[2];
-        let __v_7: G = __b1_out[3];
-        let __v_8: G = __b1_out[4];
-        let __v_9: G = __b1_out[5];
-        let __v_10: G = __b1_out[6];
-        let __v_11: G = __b1_out[7];
-        let __v_12: G = G::from_u64(2);
-        let __v_13: G = (__v_12 * __v_5);
-        let __v_14: G = G::from_u64(4);
-        let __v_15: G = (__v_14 * __v_6);
-        let __v_16: G = G::from_u64(8);
-        let __v_17: G = (__v_16 * __v_7);
-        let __v_18: G = G::from_u64(16);
-        let __v_19: G = (__v_18 * __v_8);
-        let __v_20: G = G::from_u64(32);
-        let __v_21: G = (__v_20 * __v_9);
-        let __v_22: G = G::from_u64(64);
-        let __v_23: G = (__v_22 * __v_10);
-        let __v_24: G = (__v_21 + __v_23);
-        let __v_25: G = (__v_19 + __v_24);
-        let __v_26: G = (__v_17 + __v_25);
-        let __v_27: G = (__v_15 + __v_26);
-        let __v_28: G = (__v_13 + __v_27);
-        let __v_29: G = (__v_4 + __v_28);
-        match __v_11.as_canonical_u64() {
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(1);
+        if (__v_1 != __v_2) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_70] = [__v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1];
+        record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[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) };
+        let __v_3: G = __b1_out[0];
+        let __v_4: G = __b1_out[1];
+        let __v_5: G = __b1_out[2];
+        let __v_6: G = __b1_out[3];
+        let __v_7: G = __b1_out[4];
+        let __v_8: G = __b1_out[5];
+        let __v_9: G = __b1_out[6];
+        let __v_10: G = __b1_out[7];
+        let __v_11: G = G::from_u64(2);
+        let __v_12: G = (__v_11 * __v_4);
+        let __v_13: G = G::from_u64(4);
+        let __v_14: G = (__v_13 * __v_5);
+        let __v_15: G = G::from_u64(8);
+        let __v_16: G = (__v_15 * __v_6);
+        let __v_17: G = G::from_u64(16);
+        let __v_18: G = (__v_17 * __v_7);
+        let __v_19: G = G::from_u64(32);
+        let __v_20: G = (__v_19 * __v_8);
+        let __v_21: G = G::from_u64(64);
+        let __v_22: G = (__v_21 * __v_9);
+        let __v_23: G = (__v_20 + __v_22);
+        let __v_24: G = (__v_18 + __v_23);
+        let __v_25: G = (__v_16 + __v_24);
+        let __v_26: G = (__v_14 + __v_25);
+        let __v_27: G = (__v_12 + __v_26);
+        let __v_28: G = (__v_3 + __v_27);
+        match __v_10.as_canonical_u64() {
           0u64 => {
+            let __v_29: G = G::from_u64(0);
             let __v_30: G = G::from_u64(0);
             let __v_31: G = G::from_u64(0);
             let __v_32: G = G::from_u64(0);
             let __v_33: G = G::from_u64(0);
             let __v_34: G = G::from_u64(0);
             let __v_35: G = G::from_u64(0);
-            let __v_36: G = G::from_u64(0);
-            let __ret: [G; OUT_70] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3];
+            let __ret: [G; OUT_70] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_2];
             record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_30: G = G::from_u64(1);
-            let __v_31: G = (__v_29 + __v_30);
-            let __v_32: G = G::from_u64(9);
-            let __v_33: G = if unconstrained { Bytes2::less_than(&__v_31, &__v_32) } else { bytes2_less_than_value(__v_31, __v_32, record) };
-            let __v_34: G = G::from_u64(1);
-            if (__v_33 != __v_34) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("tag0: payload width exceeds 8 bytes".to_string()) });
+            let __v_29: G = G::from_u64(1);
+            let __v_30: G = (__v_28 + __v_29);
+            let __v_31: G = G::from_u64(9);
+            let __v_32: G = if unconstrained { Bytes2::less_than(&__v_30, &__v_31) } else { bytes2_less_than_value(__v_30, __v_31, record) };
+            let __v_33: G = G::from_u64(1);
+            if (__v_32 != __v_33) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("tag0: payload width exceeds 8 bytes".to_string()) });
             }
-            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_3, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } else { aiur_fn_69(__args, record, io_buffer, __cu)? } };
-            let __v_35: G = __r_arr[0];
-            let __v_36: G = __r_arr[1];
-            let __v_37: G = __r_arr[2];
-            let __v_38: G = __r_arr[3];
-            let __v_39: G = __r_arr[4];
-            let __v_40: G = __r_arr[5];
-            let __v_41: G = __r_arr[6];
-            let __v_42: G = __r_arr[7];
-            let __v_43: G = __r_arr[8];
-            let __ret: [G; OUT_70] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43];
+            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_2, __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 __v_34: G = __r_arr[0];
+            let __v_35: G = __r_arr[1];
+            let __v_36: G = __r_arr[2];
+            let __v_37: G = __r_arr[3];
+            let __v_38: G = __r_arr[4];
+            let __v_39: G = __r_arr[5];
+            let __v_40: G = __r_arr[6];
+            let __v_41: G = __r_arr[7];
+            let __v_42: G = __r_arr[8];
+            let __ret: [G; OUT_70] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42];
             record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -11391,77 +11473,83 @@ fn aiur_fn_71(
 ) -> Result<[G; OUT_71], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_2); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_2, record) };
-        let __v_4: G = __b1_out[0];
-        let __v_5: G = __b1_out[1];
-        let __v_6: G = __b1_out[2];
-        let __v_7: G = __b1_out[3];
-        let __v_8: G = __b1_out[4];
-        let __v_9: G = __b1_out[5];
-        let __v_10: G = __b1_out[6];
-        let __v_11: G = __b1_out[7];
-        let __v_12: G = G::from_u64(2);
-        let __v_13: G = (__v_12 * __v_11);
-        let __v_14: G = (__v_10 + __v_13);
-        let __v_15: G = G::from_u64(2);
-        let __v_16: G = (__v_15 * __v_5);
-        let __v_17: G = G::from_u64(4);
-        let __v_18: G = (__v_17 * __v_6);
-        let __v_19: G = G::from_u64(8);
-        let __v_20: G = (__v_19 * __v_7);
-        let __v_21: G = G::from_u64(16);
-        let __v_22: G = (__v_21 * __v_8);
-        let __v_23: G = (__v_20 + __v_22);
-        let __v_24: G = (__v_18 + __v_23);
-        let __v_25: G = (__v_16 + __v_24);
-        let __v_26: G = (__v_4 + __v_25);
-        match __v_9.as_canonical_u64() {
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(1);
+        if (__v_1 != __v_2) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_71] = [__v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1];
+        record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[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) };
+        let __v_3: G = __b1_out[0];
+        let __v_4: G = __b1_out[1];
+        let __v_5: G = __b1_out[2];
+        let __v_6: G = __b1_out[3];
+        let __v_7: G = __b1_out[4];
+        let __v_8: G = __b1_out[5];
+        let __v_9: G = __b1_out[6];
+        let __v_10: G = __b1_out[7];
+        let __v_11: G = G::from_u64(2);
+        let __v_12: G = (__v_11 * __v_10);
+        let __v_13: G = (__v_9 + __v_12);
+        let __v_14: G = G::from_u64(2);
+        let __v_15: G = (__v_14 * __v_4);
+        let __v_16: G = G::from_u64(4);
+        let __v_17: G = (__v_16 * __v_5);
+        let __v_18: G = G::from_u64(8);
+        let __v_19: G = (__v_18 * __v_6);
+        let __v_20: G = G::from_u64(16);
+        let __v_21: G = (__v_20 * __v_7);
+        let __v_22: G = (__v_19 + __v_21);
+        let __v_23: G = (__v_17 + __v_22);
+        let __v_24: G = (__v_15 + __v_23);
+        let __v_25: G = (__v_3 + __v_24);
+        match __v_8.as_canonical_u64() {
           0u64 => {
+            let __v_26: G = G::from_u64(0);
             let __v_27: G = G::from_u64(0);
             let __v_28: G = G::from_u64(0);
             let __v_29: G = G::from_u64(0);
             let __v_30: G = G::from_u64(0);
             let __v_31: G = G::from_u64(0);
             let __v_32: G = G::from_u64(0);
-            let __v_33: G = G::from_u64(0);
-            let __ret: [G; OUT_71] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
+            let __ret: [G; OUT_71] = [__v_13, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2];
             record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_27: G = G::from_u64(1);
-            let __v_28: G = (__v_26 + __v_27);
-            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } else { aiur_fn_69(__args, record, io_buffer, __cu)? } };
-            let __v_29: G = __r_arr[0];
-            let __v_30: G = __r_arr[1];
-            let __v_31: G = __r_arr[2];
-            let __v_32: G = __r_arr[3];
-            let __v_33: G = __r_arr[4];
-            let __v_34: G = __r_arr[5];
-            let __v_35: G = __r_arr[6];
-            let __v_36: G = __r_arr[7];
-            let __v_37: G = __r_arr[8];
-            let __v_38: G = G::from_u64(9);
-            let __v_39: G = if unconstrained { Bytes2::less_than(&__v_28, &__v_38) } else { bytes2_less_than_value(__v_28, __v_38, record) };
-            let __v_40: G = G::from_u64(1);
-            if (__v_39 != __v_40) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: Some("tag2: payload width exceeds 8 bytes".to_string()) });
+            let __v_26: G = G::from_u64(1);
+            let __v_27: G = (__v_25 + __v_26);
+            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_2, __v_27]; 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_28: G = __r_arr[0];
+            let __v_29: G = __r_arr[1];
+            let __v_30: G = __r_arr[2];
+            let __v_31: G = __r_arr[3];
+            let __v_32: G = __r_arr[4];
+            let __v_33: G = __r_arr[5];
+            let __v_34: G = __r_arr[6];
+            let __v_35: G = __r_arr[7];
+            let __v_36: G = __r_arr[8];
+            let __v_37: G = G::from_u64(9);
+            let __v_38: G = if unconstrained { Bytes2::less_than(&__v_27, &__v_37) } else { bytes2_less_than_value(__v_27, __v_37, record) };
+            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(), msg: Some("tag2: payload width exceeds 8 bytes".to_string()) });
             }
-            let __ret: [G; OUT_71] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
+            let __ret: [G; OUT_71] = [__v_13, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
             record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -11477,71 +11565,77 @@ fn aiur_fn_72(
 ) -> Result<[G; OUT_72], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_2); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_2, record) };
-        let __v_4: G = __b1_out[0];
-        let __v_5: G = __b1_out[1];
-        let __v_6: G = __b1_out[2];
-        let __v_7: G = __b1_out[3];
-        let __v_8: G = __b1_out[4];
-        let __v_9: G = __b1_out[5];
-        let __v_10: G = __b1_out[6];
-        let __v_11: G = __b1_out[7];
-        let __v_12: G = G::from_u64(2);
-        let __v_13: G = (__v_12 * __v_9);
-        let __v_14: G = G::from_u64(4);
-        let __v_15: G = (__v_14 * __v_10);
-        let __v_16: G = G::from_u64(8);
-        let __v_17: G = (__v_16 * __v_11);
-        let __v_18: G = (__v_15 + __v_17);
-        let __v_19: G = (__v_13 + __v_18);
-        let __v_20: G = (__v_8 + __v_19);
-        let __v_21: G = G::from_u64(2);
-        let __v_22: G = (__v_21 * __v_5);
-        let __v_23: G = G::from_u64(4);
-        let __v_24: G = (__v_23 * __v_6);
-        let __v_25: G = (__v_22 + __v_24);
-        let __v_26: G = (__v_4 + __v_25);
-        match __v_7.as_canonical_u64() {
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(1);
+        if (__v_1 != __v_2) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_72] = [__v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1];
+        record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[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) };
+        let __v_3: G = __b1_out[0];
+        let __v_4: G = __b1_out[1];
+        let __v_5: G = __b1_out[2];
+        let __v_6: G = __b1_out[3];
+        let __v_7: G = __b1_out[4];
+        let __v_8: G = __b1_out[5];
+        let __v_9: G = __b1_out[6];
+        let __v_10: G = __b1_out[7];
+        let __v_11: G = G::from_u64(2);
+        let __v_12: G = (__v_11 * __v_8);
+        let __v_13: G = G::from_u64(4);
+        let __v_14: G = (__v_13 * __v_9);
+        let __v_15: G = G::from_u64(8);
+        let __v_16: G = (__v_15 * __v_10);
+        let __v_17: G = (__v_14 + __v_16);
+        let __v_18: G = (__v_12 + __v_17);
+        let __v_19: G = (__v_7 + __v_18);
+        let __v_20: G = G::from_u64(2);
+        let __v_21: G = (__v_20 * __v_4);
+        let __v_22: G = G::from_u64(4);
+        let __v_23: G = (__v_22 * __v_5);
+        let __v_24: G = (__v_21 + __v_23);
+        let __v_25: G = (__v_3 + __v_24);
+        match __v_6.as_canonical_u64() {
           0u64 => {
+            let __v_26: G = G::from_u64(0);
             let __v_27: G = G::from_u64(0);
             let __v_28: G = G::from_u64(0);
             let __v_29: G = G::from_u64(0);
             let __v_30: G = G::from_u64(0);
             let __v_31: G = G::from_u64(0);
             let __v_32: G = G::from_u64(0);
-            let __v_33: G = G::from_u64(0);
-            let __ret: [G; OUT_72] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
+            let __ret: [G; OUT_72] = [__v_19, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2];
             record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_27: G = G::from_u64(1);
-            let __v_28: G = (__v_26 + __v_27);
-            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } else { aiur_fn_69(__args, record, io_buffer, __cu)? } };
-            let __v_29: G = __r_arr[0];
-            let __v_30: G = __r_arr[1];
-            let __v_31: G = __r_arr[2];
-            let __v_32: G = __r_arr[3];
-            let __v_33: G = __r_arr[4];
-            let __v_34: G = __r_arr[5];
-            let __v_35: G = __r_arr[6];
-            let __v_36: G = __r_arr[7];
-            let __v_37: G = __r_arr[8];
-            let __ret: [G; OUT_72] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
+            let __v_26: G = G::from_u64(1);
+            let __v_27: G = (__v_25 + __v_26);
+            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_2, __v_27]; 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_28: G = __r_arr[0];
+            let __v_29: G = __r_arr[1];
+            let __v_30: G = __r_arr[2];
+            let __v_31: G = __r_arr[3];
+            let __v_32: G = __r_arr[4];
+            let __v_33: G = __r_arr[5];
+            let __v_34: G = __r_arr[6];
+            let __v_35: G = __r_arr[7];
+            let __v_36: G = __r_arr[8];
+            let __ret: [G; OUT_72] = [__v_19, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
             record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -11569,10 +11663,8 @@ fn aiur_fn_73(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_73] = [__v_12, __v_0];
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_73] = [__v_10, __v_0];
         record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -11599,9 +11691,8 @@ fn aiur_fn_73(
         let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
-        let __v_29: G = G::from_u64(0);
-        let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_73] = [__v_30, __v_28];
+        let __v_29: G = { let __values: [G; 9] = [__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(&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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_73] = [__v_29, __v_28];
         record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -11646,7 +11737,7 @@ fn aiur_fn_74(
         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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = __r_arr[1];
@@ -11718,7 +11809,7 @@ fn aiur_fn_75(
         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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_75] = [__v_24, __v_21];
         record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -11778,7 +11869,7 @@ fn aiur_fn_76(
         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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_76] = [__v_24, __v_21];
         record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -11816,7 +11907,7 @@ fn aiur_fn_77(
       0u64 => {
         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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_77] = [__v_13, __v_10];
         record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -11824,7 +11915,7 @@ fn aiur_fn_77(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_77] = [__v_13, __v_10];
         record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -11845,7 +11936,7 @@ fn aiur_fn_77(
         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 __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() + 1); __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));
         return Ok(__ret);
@@ -11866,7 +11957,7 @@ fn aiur_fn_77(
         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 __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() + 1); __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));
         return Ok(__ret);
@@ -11886,7 +11977,7 @@ fn aiur_fn_77(
         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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_77] = [__v_23, __v_21];
         record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -11894,7 +11985,7 @@ fn aiur_fn_77(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_77] = [__v_13, __v_10];
         record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -11902,7 +11993,7 @@ fn aiur_fn_77(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_77] = [__v_13, __v_10];
         record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -11963,7 +12054,7 @@ fn aiur_fn_77(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_77] = [__v_13, __v_10];
         record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -12005,7 +12096,7 @@ fn aiur_fn_78(
     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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_78] = [__v_17, __v_14];
     record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -12068,7 +12159,7 @@ fn aiur_fn_79(
         let __v_33: G = __r_arr[7];
         let __v_34: G = __r_arr[8];
         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_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_37: G = G::from_u64(0);
         let __ret: [G; OUT_79] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
         record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -12170,8 +12261,8 @@ fn aiur_fn_80(
         let __v_29: G = __r_arr[8];
         let __v_30: G = __r_arr[9];
         let __v_31: G = G::from_u64(2);
-        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_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() + 1); __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_34: G = G::from_u64(0);
         let __ret: [G; OUT_80] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
         record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -12201,8 +12292,8 @@ fn aiur_fn_80(
         let __v_29: G = __r_arr[8];
         let __v_30: G = __r_arr[9];
         let __v_31: G = G::from_u64(3);
-        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_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() + 1); __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_34: G = G::from_u64(0);
         let __ret: [G; OUT_80] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
         record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -12232,361 +12323,553 @@ fn aiur_fn_81(
 ) -> Result<[G; OUT_81], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_4: G = __loaded[0];
-        let __v_5: G = __loaded[1];
-        let __v_6: G = __loaded[2];
-        match __v_4.as_canonical_u64() {
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(1);
+        if (__v_1 != __v_2) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_81] = [__v_1, __v_1];
+        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        match __v_2.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_7: G = __loaded[0];
-            let __v_8: G = __loaded[1];
-            let __v_9: G = __loaded[2];
-            match __v_7.as_canonical_u64() {
+            let __v_3: G = G::from_u64(0);
+            let __v_4: G = G::from_u64(1);
+            if (__v_3 != __v_4) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_81] = [__v_3, __v_3];
+            record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_3: G = __loaded[0];
+            let __v_4: G = __loaded[1];
+            match __v_4.as_canonical_u64() {
               0u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                let __v_10: G = __loaded[0];
-                let __v_11: G = __loaded[1];
-                let __v_12: G = __loaded[2];
-                match __v_10.as_canonical_u64() {
+                let __v_5: G = G::from_u64(0);
+                let __v_6: G = G::from_u64(1);
+                if (__v_5 != __v_6) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                }
+                let __ret: [G; OUT_81] = [__v_5, __v_5];
+                record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                let __v_5: G = __loaded[0];
+                let __v_6: G = __loaded[1];
+                match __v_6.as_canonical_u64() {
                   0u64 => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                    let __v_13: G = __loaded[0];
-                    let __v_14: G = __loaded[1];
-                    let __v_15: G = __loaded[2];
-                    match __v_13.as_canonical_u64() {
+                    let __v_7: G = G::from_u64(0);
+                    let __v_8: G = G::from_u64(1);
+                    if (__v_7 != __v_8) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                    }
+                    let __ret: [G; OUT_81] = [__v_7, __v_7];
+                    record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                    let __v_7: G = __loaded[0];
+                    let __v_8: G = __loaded[1];
+                    match __v_8.as_canonical_u64() {
                       0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                        let __v_16: G = __loaded[0];
-                        let __v_17: G = __loaded[1];
-                        let __v_18: G = __loaded[2];
-                        match __v_16.as_canonical_u64() {
+                        let __v_9: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                        }
+                        let __ret: [G; OUT_81] = [__v_9, __v_9];
+                        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                        let __v_9: G = __loaded[0];
+                        let __v_10: G = __loaded[1];
+                        match __v_10.as_canonical_u64() {
                           0u64 => {
-                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                            let __v_19: G = __loaded[0];
-                            let __v_20: G = __loaded[1];
-                            let __v_21: G = __loaded[2];
-                            match __v_19.as_canonical_u64() {
+                            let __v_11: G = G::from_u64(0);
+                            let __v_12: G = G::from_u64(1);
+                            if (__v_11 != __v_12) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                            }
+                            let __ret: [G; OUT_81] = [__v_11, __v_11];
+                            record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                            let __v_11: G = __loaded[0];
+                            let __v_12: G = __loaded[1];
+                            match __v_12.as_canonical_u64() {
                               0u64 => {
-                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                let __v_22: G = __loaded[0];
-                                let __v_23: G = __loaded[1];
-                                let __v_24: G = __loaded[2];
-                                match __v_22.as_canonical_u64() {
+                                let __v_13: G = G::from_u64(0);
+                                let __v_14: G = G::from_u64(1);
+                                if (__v_13 != __v_14) {
+                                  return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                }
+                                let __ret: [G; OUT_81] = [__v_13, __v_13];
+                                record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                let __v_13: G = __loaded[0];
+                                let __v_14: G = __loaded[1];
+                                match __v_14.as_canonical_u64() {
                                   0u64 => {
-                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                    let __v_25: G = __loaded[0];
-                                    let __v_26: G = __loaded[1];
-                                    let __v_27: G = __loaded[2];
-                                    match __v_25.as_canonical_u64() {
+                                    let __v_15: G = G::from_u64(0);
+                                    let __v_16: G = G::from_u64(1);
+                                    if (__v_15 != __v_16) {
+                                      return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                    }
+                                    let __ret: [G; OUT_81] = [__v_15, __v_15];
+                                    record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                    let __v_15: G = __loaded[0];
+                                    let __v_16: G = __loaded[1];
+                                    match __v_16.as_canonical_u64() {
                                       0u64 => {
-                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                        let __v_28: G = __loaded[0];
-                                        let __v_29: G = __loaded[1];
-                                        let __v_30: G = __loaded[2];
-                                        match __v_28.as_canonical_u64() {
+                                        let __v_17: G = G::from_u64(0);
+                                        let __v_18: G = G::from_u64(1);
+                                        if (__v_17 != __v_18) {
+                                          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                        }
+                                        let __ret: [G; OUT_81] = [__v_17, __v_17];
+                                        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                        let __v_17: G = __loaded[0];
+                                        let __v_18: G = __loaded[1];
+                                        match __v_18.as_canonical_u64() {
                                           0u64 => {
-                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                            let __v_31: G = __loaded[0];
-                                            let __v_32: G = __loaded[1];
-                                            let __v_33: G = __loaded[2];
-                                            match __v_31.as_canonical_u64() {
+                                            let __v_19: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                            }
+                                            let __ret: [G; OUT_81] = [__v_19, __v_19];
+                                            record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            return Ok(__ret);
+                                          },
+                                          _ => {
+                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                            let __v_19: G = __loaded[0];
+                                            let __v_20: G = __loaded[1];
+                                            match __v_20.as_canonical_u64() {
                                               0u64 => {
-                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                let __v_34: G = __loaded[0];
-                                                let __v_35: G = __loaded[1];
-                                                let __v_36: G = __loaded[2];
-                                                match __v_34.as_canonical_u64() {
+                                                let __v_21: G = G::from_u64(0);
+                                                let __v_22: G = G::from_u64(1);
+                                                if (__v_21 != __v_22) {
+                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                }
+                                                let __ret: [G; OUT_81] = [__v_21, __v_21];
+                                                record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                return Ok(__ret);
+                                              },
+                                              _ => {
+                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                let __v_21: G = __loaded[0];
+                                                let __v_22: G = __loaded[1];
+                                                match __v_22.as_canonical_u64() {
                                                   0u64 => {
-                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                    let __v_37: G = __loaded[0];
-                                                    let __v_38: G = __loaded[1];
-                                                    let __v_39: G = __loaded[2];
-                                                    match __v_37.as_canonical_u64() {
+                                                    let __v_23: G = G::from_u64(0);
+                                                    let __v_24: G = G::from_u64(1);
+                                                    if (__v_23 != __v_24) {
+                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                    }
+                                                    let __ret: [G; OUT_81] = [__v_23, __v_23];
+                                                    record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    return Ok(__ret);
+                                                  },
+                                                  _ => {
+                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                    let __v_23: G = __loaded[0];
+                                                    let __v_24: G = __loaded[1];
+                                                    match __v_24.as_canonical_u64() {
                                                       0u64 => {
-                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                        let __v_40: G = __loaded[0];
-                                                        let __v_41: G = __loaded[1];
-                                                        let __v_42: G = __loaded[2];
-                                                        match __v_40.as_canonical_u64() {
+                                                        let __v_25: G = G::from_u64(0);
+                                                        let __v_26: G = G::from_u64(1);
+                                                        if (__v_25 != __v_26) {
+                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                        }
+                                                        let __ret: [G; OUT_81] = [__v_25, __v_25];
+                                                        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                        return Ok(__ret);
+                                                      },
+                                                      _ => {
+                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                        let __v_25: G = __loaded[0];
+                                                        let __v_26: G = __loaded[1];
+                                                        match __v_26.as_canonical_u64() {
                                                           0u64 => {
-                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                            let __v_43: G = __loaded[0];
-                                                            let __v_44: G = __loaded[1];
-                                                            let __v_45: G = __loaded[2];
-                                                            match __v_43.as_canonical_u64() {
+                                                            let __v_27: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                            }
+                                                            let __ret: [G; OUT_81] = [__v_27, __v_27];
+                                                            record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            return Ok(__ret);
+                                                          },
+                                                          _ => {
+                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                            let __v_27: G = __loaded[0];
+                                                            let __v_28: G = __loaded[1];
+                                                            match __v_28.as_canonical_u64() {
                                                               0u64 => {
-                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                let __v_46: G = __loaded[0];
-                                                                let __v_47: G = __loaded[1];
-                                                                let __v_48: G = __loaded[2];
-                                                                match __v_46.as_canonical_u64() {
+                                                                let __v_29: G = G::from_u64(0);
+                                                                let __v_30: G = G::from_u64(1);
+                                                                if (__v_29 != __v_30) {
+                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                }
+                                                                let __ret: [G; OUT_81] = [__v_29, __v_29];
+                                                                record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                return Ok(__ret);
+                                                              },
+                                                              _ => {
+                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                let __v_29: G = __loaded[0];
+                                                                let __v_30: G = __loaded[1];
+                                                                match __v_30.as_canonical_u64() {
                                                                   0u64 => {
-                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                    let __v_49: G = __loaded[0];
-                                                                    let __v_50: G = __loaded[1];
-                                                                    let __v_51: G = __loaded[2];
-                                                                    match __v_49.as_canonical_u64() {
+                                                                    let __v_31: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                    }
+                                                                    let __ret: [G; OUT_81] = [__v_31, __v_31];
+                                                                    record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                    return Ok(__ret);
+                                                                  },
+                                                                  _ => {
+                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                    let __v_31: G = __loaded[0];
+                                                                    let __v_32: G = __loaded[1];
+                                                                    match __v_32.as_canonical_u64() {
                                                                       0u64 => {
-                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                        let __v_52: G = __loaded[0];
-                                                                        let __v_53: G = __loaded[1];
-                                                                        let __v_54: G = __loaded[2];
-                                                                        match __v_52.as_canonical_u64() {
+                                                                        let __v_33: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                        }
+                                                                        let __ret: [G; OUT_81] = [__v_33, __v_33];
+                                                                        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                        return Ok(__ret);
+                                                                      },
+                                                                      _ => {
+                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_32.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                        let __v_33: G = __loaded[0];
+                                                                        let __v_34: G = __loaded[1];
+                                                                        match __v_34.as_canonical_u64() {
                                                                           0u64 => {
-                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                            let __v_55: G = __loaded[0];
-                                                                            let __v_56: G = __loaded[1];
-                                                                            let __v_57: G = __loaded[2];
-                                                                            match __v_55.as_canonical_u64() {
+                                                                            let __v_35: G = G::from_u64(0);
+                                                                            let __v_36: G = G::from_u64(1);
+                                                                            if (__v_35 != __v_36) {
+                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                            }
+                                                                            let __ret: [G; OUT_81] = [__v_35, __v_35];
+                                                                            record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                            return Ok(__ret);
+                                                                          },
+                                                                          _ => {
+                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                            let __v_35: G = __loaded[0];
+                                                                            let __v_36: G = __loaded[1];
+                                                                            match __v_36.as_canonical_u64() {
                                                                               0u64 => {
-                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                let __v_58: G = __loaded[0];
-                                                                                let __v_59: G = __loaded[1];
-                                                                                let __v_60: G = __loaded[2];
-                                                                                match __v_58.as_canonical_u64() {
+                                                                                let __v_37: G = G::from_u64(0);
+                                                                                let __v_38: G = G::from_u64(1);
+                                                                                if (__v_37 != __v_38) {
+                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_38.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                }
+                                                                                let __ret: [G; OUT_81] = [__v_37, __v_37];
+                                                                                record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                return Ok(__ret);
+                                                                              },
+                                                                              _ => {
+                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                let __v_37: G = __loaded[0];
+                                                                                let __v_38: G = __loaded[1];
+                                                                                match __v_38.as_canonical_u64() {
                                                                                   0u64 => {
-                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                    let __v_61: G = __loaded[0];
-                                                                                    let __v_62: G = __loaded[1];
-                                                                                    let __v_63: G = __loaded[2];
-                                                                                    match __v_61.as_canonical_u64() {
+                                                                                    let __v_39: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                    }
+                                                                                    let __ret: [G; OUT_81] = [__v_39, __v_39];
+                                                                                    record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                    return Ok(__ret);
+                                                                                  },
+                                                                                  _ => {
+                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_38.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                    let __v_39: G = __loaded[0];
+                                                                                    let __v_40: G = __loaded[1];
+                                                                                    match __v_40.as_canonical_u64() {
                                                                                       0u64 => {
-                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                        let __v_64: G = __loaded[0];
-                                                                                        let __v_65: G = __loaded[1];
-                                                                                        let __v_66: G = __loaded[2];
-                                                                                        match __v_64.as_canonical_u64() {
+                                                                                        let __v_41: G = G::from_u64(0);
+                                                                                        let __v_42: G = G::from_u64(1);
+                                                                                        if (__v_41 != __v_42) {
+                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                        }
+                                                                                        let __ret: [G; OUT_81] = [__v_41, __v_41];
+                                                                                        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                        return Ok(__ret);
+                                                                                      },
+                                                                                      _ => {
+                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                        let __v_41: G = __loaded[0];
+                                                                                        let __v_42: G = __loaded[1];
+                                                                                        match __v_42.as_canonical_u64() {
                                                                                           0u64 => {
-                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                            let __v_67: G = __loaded[0];
-                                                                                            let __v_68: G = __loaded[1];
-                                                                                            let __v_69: G = __loaded[2];
-                                                                                            match __v_67.as_canonical_u64() {
+                                                                                            let __v_43: G = G::from_u64(0);
+                                                                                            let __v_44: G = G::from_u64(1);
+                                                                                            if (__v_43 != __v_44) {
+                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                            }
+                                                                                            let __ret: [G; OUT_81] = [__v_43, __v_43];
+                                                                                            record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                            return Ok(__ret);
+                                                                                          },
+                                                                                          _ => {
+                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                            let __v_43: G = __loaded[0];
+                                                                                            let __v_44: G = __loaded[1];
+                                                                                            match __v_44.as_canonical_u64() {
                                                                                               0u64 => {
-                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                let __v_70: G = __loaded[0];
-                                                                                                let __v_71: G = __loaded[1];
-                                                                                                let __v_72: G = __loaded[2];
-                                                                                                match __v_70.as_canonical_u64() {
+                                                                                                let __v_45: G = G::from_u64(0);
+                                                                                                let __v_46: G = G::from_u64(1);
+                                                                                                if (__v_45 != __v_46) {
+                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                }
+                                                                                                let __ret: [G; OUT_81] = [__v_45, __v_45];
+                                                                                                record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                return Ok(__ret);
+                                                                                              },
+                                                                                              _ => {
+                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_44.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                let __v_45: G = __loaded[0];
+                                                                                                let __v_46: G = __loaded[1];
+                                                                                                match __v_46.as_canonical_u64() {
                                                                                                   0u64 => {
-                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                    let __v_73: G = __loaded[0];
-                                                                                                    let __v_74: G = __loaded[1];
-                                                                                                    let __v_75: G = __loaded[2];
-                                                                                                    match __v_73.as_canonical_u64() {
+                                                                                                    let __v_47: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                    }
+                                                                                                    let __ret: [G; OUT_81] = [__v_47, __v_47];
+                                                                                                    record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                    return Ok(__ret);
+                                                                                                  },
+                                                                                                  _ => {
+                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_46.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                    let __v_47: G = __loaded[0];
+                                                                                                    let __v_48: G = __loaded[1];
+                                                                                                    match __v_48.as_canonical_u64() {
                                                                                                       0u64 => {
-                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                        let __v_76: G = __loaded[0];
-                                                                                                        let __v_77: G = __loaded[1];
-                                                                                                        let __v_78: G = __loaded[2];
-                                                                                                        match __v_76.as_canonical_u64() {
+                                                                                                        let __v_49: G = G::from_u64(0);
+                                                                                                        let __v_50: G = G::from_u64(1);
+                                                                                                        if (__v_49 != __v_50) {
+                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                        }
+                                                                                                        let __ret: [G; OUT_81] = [__v_49, __v_49];
+                                                                                                        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                        return Ok(__ret);
+                                                                                                      },
+                                                                                                      _ => {
+                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                        let __v_49: G = __loaded[0];
+                                                                                                        let __v_50: G = __loaded[1];
+                                                                                                        match __v_50.as_canonical_u64() {
                                                                                                           0u64 => {
-                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                            let __v_79: G = __loaded[0];
-                                                                                                            let __v_80: G = __loaded[1];
-                                                                                                            let __v_81: G = __loaded[2];
-                                                                                                            match __v_79.as_canonical_u64() {
+                                                                                                            let __v_51: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                            }
+                                                                                                            let __ret: [G; OUT_81] = [__v_51, __v_51];
+                                                                                                            record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                            return Ok(__ret);
+                                                                                                          },
+                                                                                                          _ => {
+                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                            let __v_51: G = __loaded[0];
+                                                                                                            let __v_52: G = __loaded[1];
+                                                                                                            match __v_52.as_canonical_u64() {
                                                                                                               0u64 => {
-                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                let __v_82: G = __loaded[0];
-                                                                                                                let __v_83: G = __loaded[1];
-                                                                                                                let __v_84: G = __loaded[2];
-                                                                                                                match __v_82.as_canonical_u64() {
+                                                                                                                let __v_53: G = G::from_u64(0);
+                                                                                                                let __v_54: G = G::from_u64(1);
+                                                                                                                if (__v_53 != __v_54) {
+                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                }
+                                                                                                                let __ret: [G; OUT_81] = [__v_53, __v_53];
+                                                                                                                record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                return Ok(__ret);
+                                                                                                              },
+                                                                                                              _ => {
+                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_52.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                let __v_53: G = __loaded[0];
+                                                                                                                let __v_54: G = __loaded[1];
+                                                                                                                match __v_54.as_canonical_u64() {
                                                                                                                   0u64 => {
-                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                    let __v_85: G = __loaded[0];
-                                                                                                                    let __v_86: G = __loaded[1];
-                                                                                                                    let __v_87: G = __loaded[2];
-                                                                                                                    match __v_85.as_canonical_u64() {
+                                                                                                                    let __v_55: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                    }
+                                                                                                                    let __ret: [G; OUT_81] = [__v_55, __v_55];
+                                                                                                                    record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                    return Ok(__ret);
+                                                                                                                  },
+                                                                                                                  _ => {
+                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                    let __v_55: G = __loaded[0];
+                                                                                                                    let __v_56: G = __loaded[1];
+                                                                                                                    match __v_56.as_canonical_u64() {
                                                                                                                       0u64 => {
-                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                        let __v_88: G = __loaded[0];
-                                                                                                                        let __v_89: G = __loaded[1];
-                                                                                                                        let __v_90: G = __loaded[2];
-                                                                                                                        match __v_88.as_canonical_u64() {
+                                                                                                                        let __v_57: G = G::from_u64(0);
+                                                                                                                        let __v_58: G = G::from_u64(1);
+                                                                                                                        if (__v_57 != __v_58) {
+                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                        }
+                                                                                                                        let __ret: [G; OUT_81] = [__v_57, __v_57];
+                                                                                                                        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                        return Ok(__ret);
+                                                                                                                      },
+                                                                                                                      _ => {
+                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                        let __v_57: G = __loaded[0];
+                                                                                                                        let __v_58: G = __loaded[1];
+                                                                                                                        match __v_58.as_canonical_u64() {
                                                                                                                           0u64 => {
-                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                            let __v_91: G = __loaded[0];
-                                                                                                                            let __v_92: G = __loaded[1];
-                                                                                                                            let __v_93: G = __loaded[2];
-                                                                                                                            match __v_91.as_canonical_u64() {
+                                                                                                                            let __v_59: G = G::from_u64(0);
+                                                                                                                            let __v_60: G = G::from_u64(1);
+                                                                                                                            if (__v_59 != __v_60) {
+                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                            }
+                                                                                                                            let __ret: [G; OUT_81] = [__v_59, __v_59];
+                                                                                                                            record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                            return Ok(__ret);
+                                                                                                                          },
+                                                                                                                          _ => {
+                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_58.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                            let __v_59: G = __loaded[0];
+                                                                                                                            let __v_60: G = __loaded[1];
+                                                                                                                            match __v_60.as_canonical_u64() {
                                                                                                                               0u64 => {
-                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                let __v_94: G = __loaded[0];
-                                                                                                                                let __v_95: G = __loaded[1];
-                                                                                                                                let __v_96: G = __loaded[2];
-                                                                                                                                match __v_94.as_canonical_u64() {
+                                                                                                                                let __v_61: G = G::from_u64(0);
+                                                                                                                                let __v_62: G = G::from_u64(1);
+                                                                                                                                if (__v_61 != __v_62) {
+                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                }
+                                                                                                                                let __ret: [G; OUT_81] = [__v_61, __v_61];
+                                                                                                                                record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                return Ok(__ret);
+                                                                                                                              },
+                                                                                                                              _ => {
+                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                let __v_61: G = __loaded[0];
+                                                                                                                                let __v_62: G = __loaded[1];
+                                                                                                                                match __v_62.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_81] = [__v_97, __v_96];
+                                                                                                                                    let __v_63: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                    }
+                                                                                                                                    let __ret: [G; OUT_81] = [__v_63, __v_63];
                                                                                                                                     record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                                     return Ok(__ret);
                                                                                                                                   },
                                                                                                                                   _ => {
-                                                                                                                                    return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64()));
+                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_62.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                    let __v_63: G = __loaded[0];
+                                                                                                                                    let __v_64: G = __loaded[1];
+                                                                                                                                    let __v_65: G = { let __values: [G; 32] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_17, __v_19, __v_21, __v_23, __v_25, __v_27, __v_29, __v_31, __v_33, __v_35, __v_37, __v_39, __v_41, __v_43, __v_45, __v_47, __v_49, __v_51, __v_53, __v_55, __v_57, __v_59, __v_61, __v_63]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                                                                                                    let __ret: [G; OUT_81] = [__v_65, __v_64];
+                                                                                                                                    record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                    return Ok(__ret);
                                                                                                                                   },
                                                                                                                                 }
                                                                                                                               },
-                                                                                                                              _ => {
-                                                                                                                                return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64()));
-                                                                                                                              },
                                                                                                                             }
                                                                                                                           },
-                                                                                                                          _ => {
-                                                                                                                            return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64()));
-                                                                                                                          },
                                                                                                                         }
                                                                                                                       },
-                                                                                                                      _ => {
-                                                                                                                        return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64()));
-                                                                                                                      },
                                                                                                                     }
                                                                                                                   },
-                                                                                                                  _ => {
-                                                                                                                    return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64()));
-                                                                                                                  },
                                                                                                                 }
                                                                                                               },
-                                                                                                              _ => {
-                                                                                                                return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64()));
-                                                                                                              },
                                                                                                             }
                                                                                                           },
-                                                                                                          _ => {
-                                                                                                            return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64()));
-                                                                                                          },
                                                                                                         }
                                                                                                       },
-                                                                                                      _ => {
-                                                                                                        return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64()));
-                                                                                                      },
                                                                                                     }
                                                                                                   },
-                                                                                                  _ => {
-                                                                                                    return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64()));
-                                                                                                  },
                                                                                                 }
                                                                                               },
-                                                                                              _ => {
-                                                                                                return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64()));
-                                                                                              },
                                                                                             }
                                                                                           },
-                                                                                          _ => {
-                                                                                            return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64()));
-                                                                                          },
                                                                                         }
                                                                                       },
-                                                                                      _ => {
-                                                                                        return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
-                                                                                      },
                                                                                     }
                                                                                   },
-                                                                                  _ => {
-                                                                                    return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64()));
-                                                                                  },
                                                                                 }
                                                                               },
-                                                                              _ => {
-                                                                                return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64()));
-                                                                              },
                                                                             }
                                                                           },
-                                                                          _ => {
-                                                                            return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64()));
-                                                                          },
                                                                         }
                                                                       },
-                                                                      _ => {
-                                                                        return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64()));
-                                                                      },
                                                                     }
                                                                   },
-                                                                  _ => {
-                                                                    return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64()));
-                                                                  },
                                                                 }
                                                               },
-                                                              _ => {
-                                                                return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64()));
-                                                              },
                                                             }
                                                           },
-                                                          _ => {
-                                                            return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64()));
-                                                          },
                                                         }
                                                       },
-                                                      _ => {
-                                                        return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64()));
-                                                      },
                                                     }
                                                   },
-                                                  _ => {
-                                                    return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
-                                                  },
                                                 }
                                               },
-                                              _ => {
-                                                return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
-                                              },
                                             }
                                           },
-                                          _ => {
-                                            return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
-                                          },
                                         }
                                       },
-                                      _ => {
-                                        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
-                                      },
                                     }
                                   },
-                                  _ => {
-                                    return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
-                                  },
                                 }
                               },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
-                              },
                             }
                           },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-                          },
                         }
                       },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-                      },
                     }
                   },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-                  },
                 }
               },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-              },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -12614,10 +12897,8 @@ fn aiur_fn_82(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_82] = [__v_12, __v_0];
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_82] = [__v_10, __v_0];
         record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -12637,9 +12918,8 @@ fn aiur_fn_82(
         let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
-        let __v_22: G = G::from_u64(0);
-        let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_82] = [__v_23, __v_21];
+        let __v_22: G = { let __values: [G; 2] = [__v_10, __v_20]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_82] = [__v_22, __v_21];
         record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -12673,10 +12953,8 @@ fn aiur_fn_83(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_83] = [__v_12, __v_0];
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_83] = [__v_10, __v_0];
         record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -12704,10 +12982,9 @@ fn aiur_fn_83(
         let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
-        let __v_30: G = G::from_u64(0);
-        let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_83] = [__v_32, __v_29];
+        let __v_30: 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_31: G = { let __values: [G; 2] = [__v_30, __v_28]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_83] = [__v_31, __v_29];
         record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -12741,10 +13018,8 @@ fn aiur_fn_84(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_84] = [__v_12, __v_0];
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_84] = [__v_10, __v_0];
         record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -12764,9 +13039,8 @@ fn aiur_fn_84(
         let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
-        let __v_22: G = G::from_u64(0);
-        let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_84] = [__v_23, __v_21];
+        let __v_22: G = { let __values: [G; 2] = [__v_10, __v_20]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_84] = [__v_22, __v_21];
         record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -13041,10 +13315,8 @@ fn aiur_fn_91(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_91] = [__v_12, __v_0];
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_91] = [__v_10, __v_0];
         record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -13074,9 +13346,8 @@ fn aiur_fn_91(
         let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__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[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_29: G = __r_arr[0];
         let __v_30: G = __r_arr[1];
-        let __v_31: G = G::from_u64(0);
-        let __v_32: G = { let __values: [G; 11] = [__v_31, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_29]; 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_91] = [__v_32, __v_30];
+        let __v_31: G = { let __values: [G; 10] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_91] = [__v_31, __v_30];
         record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -13404,10 +13675,8 @@ fn aiur_fn_98(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_98] = [__v_12, __v_0];
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_98] = [__v_10, __v_0];
         record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -13460,9 +13729,8 @@ fn aiur_fn_98(
         let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__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[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_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_98] = [__v_56, __v_54];
+        let __v_55: G = { let __values: [G; 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_28, __v_29, __v_30, __v_31, __v_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(&35).ok_or(ExecError::InvalidMemorySize(35))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_98] = [__v_55, __v_54];
         record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -13772,10 +14040,8 @@ fn aiur_fn_103(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_103] = [__v_12, __v_0];
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_103] = [__v_10, __v_0];
         record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -13839,9 +14105,8 @@ fn aiur_fn_103(
         let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__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[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_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_103] = [__v_67, __v_65];
+        let __v_66: G = { let __values: [G; 46] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(&46).ok_or(ExecError::InvalidMemorySize(46))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_103] = [__v_66, __v_65];
         record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -14361,7 +14626,7 @@ fn aiur_fn_107(
 ) -> Result<[G; OUT_107], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -14378,10 +14643,8 @@ fn aiur_fn_107(
         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_107] = [__v_0, __v_7];
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_107] = [__v_0, __v_5];
         record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -14400,77 +14663,68 @@ fn aiur_fn_108(
 ) -> Result<[G; OUT_108], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = G::from_u64(0);
-        let __v_16: G = G::from_u64(0);
-        let __v_17: G = G::from_u64(0);
-        let __v_18: G = G::from_u64(0);
-        let __v_19: G = G::from_u64(0);
-        let __v_20: G = G::from_u64(1);
-        let __v_21: G = G::from_u64(1);
-        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_108] = [__v_23];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = { let __values: [G; 9] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_108] = [__v_10];
         record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_11: G = G::from_u64(1);
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
         let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
         let __v_15: G = G::from_u64(0);
         let __v_16: G = G::from_u64(0);
         let __v_17: G = G::from_u64(0);
-        let __v_18: G = G::from_u64(0);
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __v_20: G = __r_arr[1];
-        let __v_21: G = __r_arr[2];
-        let __v_22: G = __r_arr[3];
-        let __v_23: G = __r_arr[4];
-        let __v_24: G = __r_arr[5];
-        let __v_25: G = __r_arr[6];
-        let __v_26: G = __r_arr[7];
-        let __v_27: G = __r_arr[8];
-        match __v_27.as_canonical_u64() {
+        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __v_18: G = __r_arr[0];
+        let __v_19: G = __r_arr[1];
+        let __v_20: G = __r_arr[2];
+        let __v_21: G = __r_arr[3];
+        let __v_22: G = __r_arr[4];
+        let __v_23: G = __r_arr[5];
+        let __v_24: G = __r_arr[6];
+        let __v_25: G = __r_arr[7];
+        let __v_26: G = __r_arr[8];
+        match __v_26.as_canonical_u64() {
           0u64 => {
-            let __v_28: G = G::from_u64(0);
-            let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_108] = [__v_29];
+            let __v_27: G = { let __values: [G; 9] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_9]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_108] = [__v_27];
             record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_28: G = G::from_u64(0);
-            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_10]; 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_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_108] = [__v_30];
+            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_9]; 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_27: G = __r_arr[0];
+            let __v_28: G = { let __values: [G; 9] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_27]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_108] = [__v_28];
             record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -14488,19 +14742,8 @@ fn aiur_fn_109(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    let __v_9: G = __loaded[6];
-    let __v_10: G = __loaded[7];
-    let __v_11: G = __loaded[8];
-    let __v_12: G = __loaded[9];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __ret: [G; OUT_109] = [__v_1];
@@ -14509,27 +14752,26 @@ fn aiur_fn_109(
           },
           _ => {
             let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_109] = [__v_13];
+            let __v_3: G = __r_arr[0];
+            let __ret: [G; OUT_109] = [__v_3];
             record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        let __v_16: G = __loaded[3];
-        let __v_17: G = __loaded[4];
-        let __v_18: G = __loaded[5];
-        let __v_19: G = __loaded[6];
-        let __v_20: G = __loaded[7];
-        let __v_21: G = __loaded[8];
-        let __v_22: G = __loaded[9];
-        match __v_13.as_canonical_u64() {
-          1u64 => {
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        let __v_7: G = __loaded[4];
+        let __v_8: G = __loaded[5];
+        let __v_9: G = __loaded[6];
+        let __v_10: G = __loaded[7];
+        let __v_11: G = __loaded[8];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
             match __v_2.as_canonical_u64() {
               0u64 => {
                 let __ret: [G; OUT_109] = [__v_0];
@@ -14538,58 +14780,61 @@ fn aiur_fn_109(
               },
               _ => {
                 let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0]; 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_23: G = __r_arr[0];
-                let __ret: [G; OUT_109] = [__v_23];
+                let __v_12: G = __r_arr[0];
+                let __ret: [G; OUT_109] = [__v_12];
                 record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          0u64 => {
-            let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            let __v_25: G = __r_arr[2];
-            let __v_26: G = __r_arr[3];
-            let __v_27: G = __r_arr[4];
-            let __v_28: G = __r_arr[5];
-            let __v_29: G = __r_arr[6];
-            let __v_30: G = __r_arr[7];
-            let __v_31: G = __r_arr[8];
+          _ => {
+            let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+            let __v_12: G = __loaded[0];
+            let __v_13: G = __loaded[1];
+            let __v_14: G = __loaded[2];
+            let __v_15: G = __loaded[3];
+            let __v_16: G = __loaded[4];
+            let __v_17: G = __loaded[5];
+            let __v_18: G = __loaded[6];
+            let __v_19: G = __loaded[7];
+            let __v_20: G = __loaded[8];
+            let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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]; 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_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __v_23: G = __r_arr[2];
+            let __v_24: G = __r_arr[3];
+            let __v_25: G = __r_arr[4];
+            let __v_26: G = __r_arr[5];
+            let __v_27: G = __r_arr[6];
+            let __v_28: G = __r_arr[7];
+            let __v_29: G = __r_arr[8];
+            let __v_30: G = G::from_u64(0);
+            let __v_31: G = G::from_u64(0);
             let __v_32: G = G::from_u64(0);
             let __v_33: G = G::from_u64(0);
             let __v_34: G = G::from_u64(0);
             let __v_35: G = G::from_u64(0);
             let __v_36: G = G::from_u64(0);
-            let __v_37: G = G::from_u64(0);
-            let __v_38: G = G::from_u64(0);
-            let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
-            let __v_39: G = __r_arr[0];
-            let __v_40: G = __r_arr[1];
-            let __v_41: G = __r_arr[2];
-            let __v_42: G = __r_arr[3];
-            let __v_43: G = __r_arr[4];
-            let __v_44: G = __r_arr[5];
-            let __v_45: G = __r_arr[6];
-            let __v_46: G = __r_arr[7];
-            let __v_47: G = __r_arr[8];
-            let __v_48: G = (__v_31 + __v_47);
-            let __v_49: G = G::from_u64(0);
-            let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-            let __v_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_109] = [__v_51];
+            let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_2, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; 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_37: G = __r_arr[0];
+            let __v_38: G = __r_arr[1];
+            let __v_39: G = __r_arr[2];
+            let __v_40: G = __r_arr[3];
+            let __v_41: G = __r_arr[4];
+            let __v_42: G = __r_arr[5];
+            let __v_43: G = __r_arr[6];
+            let __v_44: G = __r_arr[7];
+            let __v_45: G = __r_arr[8];
+            let __v_46: G = (__v_29 + __v_45);
+            let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_11, __v_20, __v_46]; 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_47: G = __r_arr[0];
+            let __v_48: G = { let __values: [G; 9] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_109] = [__v_48];
             record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -14712,167 +14957,135 @@ fn aiur_fn_112(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    let __v_9: G = __loaded[6];
-    let __v_10: G = __loaded[7];
-    let __v_11: G = __loaded[8];
-    let __v_12: G = __loaded[9];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        let __v_16: G = __loaded[3];
-        let __v_17: G = __loaded[4];
-        let __v_18: G = __loaded[5];
-        let __v_19: G = __loaded[6];
-        let __v_20: G = __loaded[7];
-        let __v_21: G = __loaded[8];
-        let __v_22: G = __loaded[9];
-        match __v_13.as_canonical_u64() {
-          1u64 => {
-            let __v_23: G = G::from_u64(1);
-            let __v_24: G = G::from_u64(1);
-            let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_112] = [__v_25, __v_2];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_3: G = G::from_u64(0);
+            let __ret: [G; OUT_112] = [__v_3, __v_2];
             record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
+          _ => {
             let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            match __v_23.as_canonical_u64() {
+            let __v_3: G = __r_arr[0];
+            match __v_3.as_canonical_u64() {
               1u64 => {
-                let __v_24: G = G::from_u64(1);
-                let __v_25: G = G::from_u64(1);
-                let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_112] = [__v_26, __v_2];
+                let __v_4: G = G::from_u64(0);
+                let __ret: [G; OUT_112] = [__v_4, __v_2];
                 record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_24: G = G::from_u64(1);
-                let __v_25: G = G::from_u64(1);
-                let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_27: G = G::from_u64(1);
-                let __ret: [G; OUT_112] = [__v_26, __v_27];
+                let __v_4: G = G::from_u64(0);
+                let __v_5: G = G::from_u64(1);
+                let __ret: [G; OUT_112] = [__v_4, __v_5];
                 record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-          },
         }
       },
-      0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        let __v_16: G = __loaded[3];
-        let __v_17: G = __loaded[4];
-        let __v_18: G = __loaded[5];
-        let __v_19: G = __loaded[6];
-        let __v_20: G = __loaded[7];
-        let __v_21: G = __loaded[8];
-        let __v_22: G = __loaded[9];
-        match __v_13.as_canonical_u64() {
-          1u64 => {
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        let __v_7: G = __loaded[4];
+        let __v_8: G = __loaded[5];
+        let __v_9: G = __loaded[6];
+        let __v_10: G = __loaded[7];
+        let __v_11: G = __loaded[8];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
             match __v_2.as_canonical_u64() {
               0u64 => {
-                let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_112] = [__v_0, __v_23];
+                let __v_12: G = G::from_u64(0);
+                let __ret: [G; OUT_112] = [__v_0, __v_12];
                 record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_23: G = G::from_u64(1);
-                let __v_24: G = G::from_u64(0);
-                let __v_25: G = G::from_u64(0);
-                let __v_26: G = G::from_u64(0);
-                let __v_27: G = G::from_u64(0);
-                let __v_28: G = G::from_u64(0);
+                let __v_12: G = G::from_u64(1);
+                let __v_13: G = G::from_u64(0);
+                let __v_14: G = G::from_u64(0);
+                let __v_15: G = G::from_u64(0);
+                let __v_16: G = G::from_u64(0);
+                let __v_17: G = G::from_u64(0);
+                let __v_18: G = G::from_u64(0);
+                let __v_19: G = G::from_u64(0);
+                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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]; 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_20: G = __r_arr[0];
+                let __v_21: G = __r_arr[1];
+                let __v_22: G = __r_arr[2];
+                let __v_23: G = __r_arr[3];
+                let __v_24: G = __r_arr[4];
+                let __v_25: G = __r_arr[5];
+                let __v_26: G = __r_arr[6];
+                let __v_27: G = __r_arr[7];
+                let __v_28: G = __r_arr[8];
                 let __v_29: G = G::from_u64(0);
-                let __v_30: G = G::from_u64(0);
-                let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[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_31: G = __r_arr[0];
-                let __v_32: G = __r_arr[1];
-                let __v_33: G = __r_arr[2];
-                let __v_34: G = __r_arr[3];
-                let __v_35: G = __r_arr[4];
-                let __v_36: G = __r_arr[5];
-                let __v_37: G = __r_arr[6];
-                let __v_38: G = __r_arr[7];
-                let __v_39: G = __r_arr[8];
-                let __v_40: G = G::from_u64(1);
-                let __v_41: G = G::from_u64(1);
-                let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_42, __v_39]; 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_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_112] = [__v_46, __v_44];
+                let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11, __v_29, __v_28]; 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_30: G = __r_arr[0];
+                let __v_31: G = __r_arr[1];
+                let __v_32: G = { let __values: [G; 9] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_30]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_112] = [__v_32, __v_31];
                 record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          0u64 => {
-            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[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_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            let __v_25: G = __r_arr[2];
-            let __v_26: G = __r_arr[3];
-            let __v_27: G = __r_arr[4];
-            let __v_28: G = __r_arr[5];
-            let __v_29: G = __r_arr[6];
-            let __v_30: G = __r_arr[7];
-            let __v_31: G = __r_arr[8];
+          _ => {
+            let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+            let __v_12: G = __loaded[0];
+            let __v_13: G = __loaded[1];
+            let __v_14: G = __loaded[2];
+            let __v_15: G = __loaded[3];
+            let __v_16: G = __loaded[4];
+            let __v_17: G = __loaded[5];
+            let __v_18: G = __loaded[6];
+            let __v_19: G = __loaded[7];
+            let __v_20: G = __loaded[8];
+            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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]; 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_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __v_23: G = __r_arr[2];
+            let __v_24: G = __r_arr[3];
+            let __v_25: G = __r_arr[4];
+            let __v_26: G = __r_arr[5];
+            let __v_27: G = __r_arr[6];
+            let __v_28: G = __r_arr[7];
+            let __v_29: G = __r_arr[8];
+            let __v_30: G = G::from_u64(0);
+            let __v_31: G = G::from_u64(0);
             let __v_32: G = G::from_u64(0);
             let __v_33: G = G::from_u64(0);
             let __v_34: G = G::from_u64(0);
             let __v_35: G = G::from_u64(0);
             let __v_36: G = G::from_u64(0);
-            let __v_37: G = G::from_u64(0);
-            let __v_38: G = G::from_u64(0);
-            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
-            let __v_39: G = __r_arr[0];
-            let __v_40: G = __r_arr[1];
-            let __v_41: G = __r_arr[2];
-            let __v_42: G = __r_arr[3];
-            let __v_43: G = __r_arr[4];
-            let __v_44: G = __r_arr[5];
-            let __v_45: G = __r_arr[6];
-            let __v_46: G = __r_arr[7];
-            let __v_47: G = __r_arr[8];
-            let __v_48: G = (__v_31 + __v_47);
-            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_22, __v_48]; 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_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_112] = [__v_52, __v_50];
+            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_2, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; 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_37: G = __r_arr[0];
+            let __v_38: G = __r_arr[1];
+            let __v_39: G = __r_arr[2];
+            let __v_40: G = __r_arr[3];
+            let __v_41: G = __r_arr[4];
+            let __v_42: G = __r_arr[5];
+            let __v_43: G = __r_arr[6];
+            let __v_44: G = __r_arr[7];
+            let __v_45: G = __r_arr[8];
+            let __v_46: G = (__v_29 + __v_45);
+            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11, __v_20, __v_46]; 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_47: G = __r_arr[0];
+            let __v_48: G = __r_arr[1];
+            let __v_49: G = { let __values: [G; 9] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_112] = [__v_49, __v_48];
             record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -14888,41 +15101,34 @@ fn aiur_fn_113(
 ) -> Result<[G; OUT_113], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_113] = [__v_13];
-        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        if !unconstrained { let __vi = __v_2; let __vj = __v_3; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __v_13: G = { let __values: [G; 10] = [__v_11, __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 __ret: [G; OUT_113] = [__v_13];
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_113] = [__v_1];
         record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        if !unconstrained { let __vi = __v_1; let __vj = __v_2; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = { let __values: [G; 9] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_113] = [__v_11];
+        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -14939,80 +15145,57 @@ fn aiur_fn_114(
 ) -> Result<[G; OUT_114], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = { let __values: [G; 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_114] = [__v_13];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_114] = [__v_1];
         record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_10]; 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_11: G = __r_arr[0];
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            match __v_22.as_canonical_u64() {
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_9]; 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_10: G = __r_arr[0];
+        match __v_10.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            match __v_11.as_canonical_u64() {
               1u64 => {
-                let __v_23: G = G::from_u64(1);
-                let __v_24: G = G::from_u64(1);
-                let __v_25: G = { let __values: [G; 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_114] = [__v_25];
+                let __v_12: G = G::from_u64(0);
+                let __ret: [G; OUT_114] = [__v_12];
                 record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __v_23: G = G::from_u64(0);
-                let __v_24: G = G::from_u64(1);
-                let __v_25: G = G::from_u64(1);
-                let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_114] = [__v_27];
+                let __v_12: G = G::from_u64(0);
+                let __v_13: G = { let __values: [G; 9] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_114] = [__v_13];
                 record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
               },
             }
           },
           _ => {
-            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_114] = [__v_23];
+            let __v_11: G = { let __values: [G; 9] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_114] = [__v_11];
             record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -15035,10 +15218,8 @@ fn aiur_fn_115(
     let __v_4: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_115] = [__v_7];
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_115] = [__v_5];
         record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -15070,27 +15251,16 @@ fn aiur_fn_116(
     let __v_1: G = inp[1];
     let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    let __v_9: G = __loaded[6];
-    let __v_10: G = __loaded[7];
-    let __v_11: G = __loaded[8];
-    let __v_12: G = __loaded[9];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_13: G = G::from_u64(1);
-        let __ret: [G; OUT_116] = [__v_13];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_116] = [__v_3];
         record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_116] = [__v_13];
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_116] = [__v_3];
         record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -15109,8 +15279,8 @@ fn aiur_fn_117(
 ) -> Result<[G; OUT_117], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(0);
-    let __v_2: G = G::from_u64(1);
+    let __v_1: G = G::from_u64(1);
+    let __v_2: G = G::from_u64(0);
     let __v_3: G = G::from_u64(0);
     let __v_4: G = G::from_u64(0);
     let __v_5: G = G::from_u64(0);
@@ -15118,13 +15288,10 @@ fn aiur_fn_117(
     let __v_7: G = G::from_u64(0);
     let __v_8: G = G::from_u64(0);
     let __v_9: G = G::from_u64(0);
-    let __v_10: G = G::from_u64(1);
-    let __v_11: G = G::from_u64(1);
-    let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0, __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 __ret: [G; OUT_117] = [__v_14];
+    let __v_10: G = { let __values: [G; 9] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0, __v_10]; 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_11: G = __r_arr[0];
+    let __ret: [G; OUT_117] = [__v_11];
     record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -15695,13 +15862,11 @@ fn aiur_fn_121(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = G::from_u64(1);
-    let __v_3: G = G::from_u64(1);
-    let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_5: G = G::from_u64(0);
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_121] = [__v_6];
+    let __v_2: G = G::from_u64(0);
+    let __v_3: G = G::from_u64(0);
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __ret: [G; OUT_121] = [__v_4];
     record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -15721,24 +15886,24 @@ fn aiur_fn_122(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    let __v_8: G = __loaded[4];
-    let __v_9: G = __loaded[5];
-    let __v_10: G = __loaded[6];
-    let __v_11: G = __loaded[7];
-    let __v_12: G = __loaded[8];
-    let __v_13: G = __loaded[9];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_122] = [__v_2];
         record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        let __v_8: G = __loaded[4];
+        let __v_9: G = __loaded[5];
+        let __v_10: G = __loaded[6];
+        let __v_11: G = __loaded[7];
+        let __v_12: G = __loaded[8];
+        let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
         let __v_15: G = G::from_u64(0);
         let __v_16: G = G::from_u64(0);
@@ -15747,26 +15912,20 @@ fn aiur_fn_122(
         let __v_19: G = G::from_u64(0);
         let __v_20: G = G::from_u64(0);
         let __v_21: G = G::from_u64(0);
-        let __v_22: G = G::from_u64(1);
-        let __v_23: G = G::from_u64(1);
-        let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__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[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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_2, __v_26]; 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_123] = { let __args: [G; IN_123] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_1, __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[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_22: G = __r_arr[0];
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __v_25: G = G::from_u64(1);
+        let __v_26: G = (__v_3 + __v_25);
+        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_12, __v_1, __v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
-        let __v_28: G = G::from_u64(1);
-        let __v_29: G = (__v_3 + __v_28);
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
-        let __v_30: G = __r_arr[0];
-        let __ret: [G; OUT_122] = [__v_30];
+        let __ret: [G; OUT_122] = [__v_27];
         record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
     }
   })
 }
@@ -15799,95 +15958,91 @@ fn aiur_fn_123(
     let __v_15: G = inp[15];
     let __v_16: G = inp[16];
     let __v_17: G = inp[17];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_18: G = __loaded[0];
-    let __v_19: G = __loaded[1];
-    let __v_20: G = __loaded[2];
-    let __v_21: G = __loaded[3];
-    let __v_22: G = __loaded[4];
-    let __v_23: G = __loaded[5];
-    let __v_24: G = __loaded[6];
-    let __v_25: G = __loaded[7];
-    let __v_26: G = __loaded[8];
-    let __v_27: G = __loaded[9];
-    match __v_18.as_canonical_u64() {
-      1u64 => {
+    match __v_8.as_canonical_u64() {
+      0u64 => {
         let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
-        let __v_28: G = __r_arr[0];
-        match __v_28.as_canonical_u64() {
+        let __v_18: G = __r_arr[0];
+        match __v_18.as_canonical_u64() {
           1u64 => {
             let __ret: [G; OUT_123] = [__v_17];
             record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__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[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_29: G = __r_arr[0];
-            let __ret: [G; OUT_123] = [__v_29];
+            let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__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[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } };
+            let __v_19: G = __r_arr[0];
+            let __ret: [G; OUT_123] = [__v_19];
             record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
           },
         }
       },
-      0u64 => {
-        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__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[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_28: G = __r_arr[0];
-        let __v_29: G = __r_arr[1];
-        let __v_30: G = __r_arr[2];
-        let __v_31: G = __r_arr[3];
-        let __v_32: G = __r_arr[4];
-        let __v_33: G = __r_arr[5];
-        let __v_34: G = __r_arr[6];
-        let __v_35: G = __r_arr[7];
-        let __v_36: G = __r_arr[8];
-        let __v_37: G = __r_arr[9];
-        let __v_38: G = __r_arr[10];
-        let __v_39: G = __r_arr[11];
-        let __v_40: G = __r_arr[12];
-        let __v_41: G = __r_arr[13];
-        let __v_42: G = __r_arr[14];
-        let __v_43: G = __r_arr[15];
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
-        let __v_44: G = __r_arr[0];
-        let __v_45: G = __r_arr[1];
-        let __v_46: G = __r_arr[2];
-        let __v_47: G = __r_arr[3];
-        let __v_48: G = __r_arr[4];
-        let __v_49: G = __r_arr[5];
-        let __v_50: G = __r_arr[6];
-        let __v_51: G = __r_arr[7];
-        let __v_52: G = __r_arr[8];
+      _ => {
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_18: G = __loaded[0];
+        let __v_19: G = __loaded[1];
+        let __v_20: G = __loaded[2];
+        let __v_21: G = __loaded[3];
+        let __v_22: G = __loaded[4];
+        let __v_23: G = __loaded[5];
+        let __v_24: G = __loaded[6];
+        let __v_25: G = __loaded[7];
+        let __v_26: G = __loaded[8];
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __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[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_27: G = __r_arr[0];
+        let __v_28: G = __r_arr[1];
+        let __v_29: G = __r_arr[2];
+        let __v_30: G = __r_arr[3];
+        let __v_31: G = __r_arr[4];
+        let __v_32: G = __r_arr[5];
+        let __v_33: G = __r_arr[6];
+        let __v_34: G = __r_arr[7];
+        let __v_35: G = __r_arr[8];
+        let __v_36: G = __r_arr[9];
+        let __v_37: G = __r_arr[10];
+        let __v_38: G = __r_arr[11];
+        let __v_39: G = __r_arr[12];
+        let __v_40: G = __r_arr[13];
+        let __v_41: G = __r_arr[14];
+        let __v_42: G = __r_arr[15];
+        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __v_43: G = __r_arr[0];
+        let __v_44: G = __r_arr[1];
+        let __v_45: G = __r_arr[2];
+        let __v_46: G = __r_arr[3];
+        let __v_47: G = __r_arr[4];
+        let __v_48: G = __r_arr[5];
+        let __v_49: G = __r_arr[6];
+        let __v_50: G = __r_arr[7];
+        let __v_51: G = __r_arr[8];
+        let __v_52: G = G::from_u64(0);
         let __v_53: G = G::from_u64(0);
         let __v_54: G = G::from_u64(0);
         let __v_55: G = G::from_u64(0);
         let __v_56: G = G::from_u64(0);
         let __v_57: G = G::from_u64(0);
         let __v_58: G = G::from_u64(0);
-        let __v_59: G = G::from_u64(0);
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
-        let __v_60: G = __r_arr[0];
-        let __v_61: G = __r_arr[1];
-        let __v_62: G = __r_arr[2];
-        let __v_63: G = __r_arr[3];
-        let __v_64: G = __r_arr[4];
-        let __v_65: G = __r_arr[5];
-        let __v_66: G = __r_arr[6];
-        let __v_67: G = __r_arr[7];
-        let __v_68: G = __r_arr[8];
-        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__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[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_12] = { let __args: [G; IN_12] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __v_59: G = __r_arr[0];
+        let __v_60: G = __r_arr[1];
+        let __v_61: G = __r_arr[2];
+        let __v_62: G = __r_arr[3];
+        let __v_63: G = __r_arr[4];
+        let __v_64: G = __r_arr[5];
+        let __v_65: G = __r_arr[6];
+        let __v_66: G = __r_arr[7];
+        let __v_67: G = __r_arr[8];
+        let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_17, __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[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } };
+        let __v_68: G = __r_arr[0];
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_26, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_68]; 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_69: G = __r_arr[0];
-        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__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[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_70: G = __r_arr[0];
-        let __ret: [G; OUT_123] = [__v_70];
+        let __ret: [G; OUT_123] = [__v_69];
         record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
-      },
     }
   })
 }
@@ -15919,13 +16074,12 @@ fn aiur_fn_124(
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = (__v_1 - __v_12);
-        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_124] = [__v_14];
+        let __v_10: G = { let __values: [G; 9] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = (__v_1 - __v_11);
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_10, __v_12]; 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_13: G = __r_arr[0];
+        let __ret: [G; OUT_124] = [__v_13];
         record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -15946,27 +16100,16 @@ fn aiur_fn_125(
     let __v_0: G = inp[0];
     let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; 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_1: G = __r_arr[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_125] = [__v_12];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_125] = [__v_2];
         record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_125] = [__v_12];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_125] = [__v_2];
         record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -16136,8 +16279,8 @@ fn aiur_fn_130(
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __v_3: G = G::from_u64(0);
-        let __v_4: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
@@ -16145,17 +16288,14 @@ fn aiur_fn_130(
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_130] = [__v_15];
+        let __v_12: G = { let __values: [G; 9] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_130] = [__v_12];
         record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __v_3: G = G::from_u64(0);
-        let __v_4: G = G::from_u64(2);
+        let __v_3: G = G::from_u64(2);
+        let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
@@ -16163,38 +16303,35 @@ fn aiur_fn_130(
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __v_17: G = __r_arr[1];
+        let __v_12: G = { let __values: [G; 9] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __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 __v_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
         let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0, __v_0]; 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_15: G = __r_arr[0];
+        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_15]; 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_16: G = __r_arr[0];
+        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __v_17: G = __r_arr[0];
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_18]; 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_125] = { let __args: [G; IN_125] = [__v_14]; 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_16]; 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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
-        let __v_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_17]; 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_22: G = __r_arr[0];
-        match __v_22.as_canonical_u64() {
+        match __v_19.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_130] = [__v_21];
+            let __ret: [G; OUT_130] = [__v_18];
             record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0, __v_21]; 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_23: G = __r_arr[0];
-            let __ret: [G; OUT_130] = [__v_23];
+            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0, __v_18]; 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_20: G = __r_arr[0];
+            let __ret: [G; OUT_130] = [__v_20];
             record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
           },
         }
       },
@@ -16337,73 +16474,60 @@ fn aiur_fn_134(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_134] = [__v_14];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_134] = [__v_2];
         record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __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_134] = [__v_24];
-            record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            let __v_25: G = __r_arr[2];
-            let __v_26: G = __r_arr[3];
-            let __v_27: G = __r_arr[4];
-            let __v_28: G = __r_arr[5];
-            let __v_29: G = __r_arr[6];
-            let __v_30: G = __r_arr[7];
-            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
-            let __v_31: G = __r_arr[0];
-            let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_134] = [__v_32];
+            let __v_11: G = G::from_u64(0);
+            let __ret: [G; OUT_134] = [__v_11];
             record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+            let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+            let __v_11: G = __loaded[0];
+            let __v_12: G = __loaded[1];
+            let __v_13: G = __loaded[2];
+            let __v_14: G = __loaded[3];
+            let __v_15: G = __loaded[4];
+            let __v_16: G = __loaded[5];
+            let __v_17: G = __loaded[6];
+            let __v_18: G = __loaded[7];
+            let __v_19: G = __loaded[8];
+            let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__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[131].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __v_21: G = __r_arr[1];
+            let __v_22: G = __r_arr[2];
+            let __v_23: G = __r_arr[3];
+            let __v_24: G = __r_arr[4];
+            let __v_25: G = __r_arr[5];
+            let __v_26: G = __r_arr[6];
+            let __v_27: G = __r_arr[7];
+            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_10, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+            let __v_28: G = __r_arr[0];
+            let __v_29: G = { let __values: [G; 9] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_134] = [__v_29];
+            record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -16420,67 +16544,58 @@ fn aiur_fn_135(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_135] = [__v_1];
         record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
+      _ => {
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
             let __ret: [G; OUT_135] = [__v_0];
             record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            let __v_25: G = __r_arr[2];
-            let __v_26: G = __r_arr[3];
-            let __v_27: G = __r_arr[4];
-            let __v_28: G = __r_arr[5];
-            let __v_29: G = __r_arr[6];
-            let __v_30: G = __r_arr[7];
-            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
-            let __v_31: G = __r_arr[0];
-            let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_135] = [__v_32];
+          _ => {
+            let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+            let __v_11: G = __loaded[0];
+            let __v_12: G = __loaded[1];
+            let __v_13: G = __loaded[2];
+            let __v_14: G = __loaded[3];
+            let __v_15: G = __loaded[4];
+            let __v_16: G = __loaded[5];
+            let __v_17: G = __loaded[6];
+            let __v_18: G = __loaded[7];
+            let __v_19: G = __loaded[8];
+            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__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[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_20: G = __r_arr[0];
+            let __v_21: G = __r_arr[1];
+            let __v_22: G = __r_arr[2];
+            let __v_23: G = __r_arr[3];
+            let __v_24: G = __r_arr[4];
+            let __v_25: G = __r_arr[5];
+            let __v_26: G = __r_arr[6];
+            let __v_27: G = __r_arr[7];
+            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_10, __v_19]; 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_28: G = __r_arr[0];
+            let __v_29: G = { let __values: [G; 9] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_135] = [__v_29];
             record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -16497,67 +16612,58 @@ fn aiur_fn_136(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_136] = [__v_1];
         record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
+      _ => {
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
             let __ret: [G; OUT_136] = [__v_0];
             record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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[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_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            let __v_25: G = __r_arr[2];
-            let __v_26: G = __r_arr[3];
-            let __v_27: G = __r_arr[4];
-            let __v_28: G = __r_arr[5];
-            let __v_29: G = __r_arr[6];
-            let __v_30: G = __r_arr[7];
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_11, __v_21]; 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_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_136] = [__v_32];
+          _ => {
+            let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+            let __v_11: G = __loaded[0];
+            let __v_12: G = __loaded[1];
+            let __v_13: G = __loaded[2];
+            let __v_14: G = __loaded[3];
+            let __v_15: G = __loaded[4];
+            let __v_16: G = __loaded[5];
+            let __v_17: G = __loaded[6];
+            let __v_18: G = __loaded[7];
+            let __v_19: G = __loaded[8];
+            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__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[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __v_21: G = __r_arr[1];
+            let __v_22: G = __r_arr[2];
+            let __v_23: G = __r_arr[3];
+            let __v_24: G = __r_arr[4];
+            let __v_25: G = __r_arr[5];
+            let __v_26: G = __r_arr[6];
+            let __v_27: G = __r_arr[7];
+            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_10, __v_19]; 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_28: G = __r_arr[0];
+            let __v_29: G = { let __values: [G; 9] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_136] = [__v_29];
             record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -16574,8 +16680,8 @@ fn aiur_fn_137(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = G::from_u64(0);
-    let __v_3: G = G::from_u64(2);
+    let __v_2: G = G::from_u64(2);
+    let __v_3: G = G::from_u64(0);
     let __v_4: G = G::from_u64(0);
     let __v_5: G = G::from_u64(0);
     let __v_6: G = G::from_u64(0);
@@ -16583,15 +16689,12 @@ fn aiur_fn_137(
     let __v_8: G = G::from_u64(0);
     let __v_9: G = G::from_u64(0);
     let __v_10: G = G::from_u64(0);
-    let __v_11: G = G::from_u64(1);
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0, __v_15]; 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_16: G = __r_arr[0];
-    let __ret: [G; OUT_137] = [__v_16];
+    let __v_11: G = { let __values: [G; 9] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_11, __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_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0, __v_12]; 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_13: G = __r_arr[0];
+    let __ret: [G; OUT_137] = [__v_13];
     record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -16609,8 +16712,8 @@ fn aiur_fn_138(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = G::from_u64(0);
-    let __v_3: G = G::from_u64(2);
+    let __v_2: G = G::from_u64(2);
+    let __v_3: G = G::from_u64(0);
     let __v_4: G = G::from_u64(0);
     let __v_5: G = G::from_u64(0);
     let __v_6: G = G::from_u64(0);
@@ -16618,15 +16721,12 @@ fn aiur_fn_138(
     let __v_8: G = G::from_u64(0);
     let __v_9: G = G::from_u64(0);
     let __v_10: G = G::from_u64(0);
-    let __v_11: G = G::from_u64(1);
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __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_16: G = __r_arr[0];
-    let __ret: [G; OUT_138] = [__v_16];
+    let __v_11: G = { let __values: [G; 9] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_11, __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_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_12]; 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_13: G = __r_arr[0];
+    let __ret: [G; OUT_138] = [__v_13];
     record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -16674,7 +16774,7 @@ fn aiur_fn_139(
     let __v_29: G = G::from_u64(70);
     let __v_30: G = G::from_u64(125);
     let __v_31: G = G::from_u64(182);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_139] = [__v_32];
     record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -16723,7 +16823,7 @@ fn aiur_fn_140(
     let __v_29: G = G::from_u64(186);
     let __v_30: G = G::from_u64(5);
     let __v_31: G = G::from_u64(110);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_140] = [__v_32];
     record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -16772,7 +16872,7 @@ fn aiur_fn_141(
     let __v_29: G = G::from_u64(89);
     let __v_30: G = G::from_u64(76);
     let __v_31: G = G::from_u64(136);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_141] = [__v_32];
     record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -16821,7 +16921,7 @@ fn aiur_fn_142(
     let __v_29: G = G::from_u64(45);
     let __v_30: G = G::from_u64(101);
     let __v_31: G = G::from_u64(1);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_142] = [__v_32];
     record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -16870,7 +16970,7 @@ fn aiur_fn_143(
     let __v_29: G = G::from_u64(51);
     let __v_30: G = G::from_u64(129);
     let __v_31: G = G::from_u64(237);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_143] = [__v_32];
     record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -16919,7 +17019,7 @@ fn aiur_fn_144(
     let __v_29: G = G::from_u64(140);
     let __v_30: G = G::from_u64(72);
     let __v_31: G = G::from_u64(211);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_144] = [__v_32];
     record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -16968,7 +17068,7 @@ fn aiur_fn_145(
     let __v_29: G = G::from_u64(57);
     let __v_30: G = G::from_u64(94);
     let __v_31: G = G::from_u64(99);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_145] = [__v_32];
     record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17017,7 +17117,7 @@ fn aiur_fn_146(
     let __v_29: G = G::from_u64(237);
     let __v_30: G = G::from_u64(16);
     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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_146] = [__v_32];
     record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17066,7 +17166,7 @@ fn aiur_fn_147(
     let __v_29: G = G::from_u64(141);
     let __v_30: G = G::from_u64(118);
     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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_147] = [__v_32];
     record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17115,7 +17215,7 @@ fn aiur_fn_148(
     let __v_29: G = G::from_u64(140);
     let __v_30: G = G::from_u64(19);
     let __v_31: G = G::from_u64(30);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_148] = [__v_32];
     record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17164,7 +17264,7 @@ fn aiur_fn_149(
     let __v_29: G = G::from_u64(203);
     let __v_30: G = G::from_u64(155);
     let __v_31: G = G::from_u64(244);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_149] = [__v_32];
     record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17213,7 +17313,7 @@ fn aiur_fn_150(
     let __v_29: G = G::from_u64(80);
     let __v_30: G = G::from_u64(153);
     let __v_31: G = G::from_u64(148);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_150] = [__v_32];
     record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17262,7 +17362,7 @@ fn aiur_fn_151(
     let __v_29: G = G::from_u64(230);
     let __v_30: G = G::from_u64(14);
     let __v_31: G = G::from_u64(56);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_151] = [__v_32];
     record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17311,7 +17411,7 @@ fn aiur_fn_152(
     let __v_29: G = G::from_u64(95);
     let __v_30: G = G::from_u64(159);
     let __v_31: G = G::from_u64(255);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_152] = [__v_32];
     record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17360,7 +17460,7 @@ fn aiur_fn_153(
     let __v_29: G = G::from_u64(218);
     let __v_30: G = G::from_u64(41);
     let __v_31: G = G::from_u64(237);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_153] = [__v_32];
     record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17409,7 +17509,7 @@ fn aiur_fn_154(
     let __v_29: G = G::from_u64(253);
     let __v_30: G = G::from_u64(158);
     let __v_31: G = G::from_u64(65);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_154] = [__v_32];
     record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17458,7 +17558,7 @@ fn aiur_fn_155(
     let __v_29: G = G::from_u64(250);
     let __v_30: G = G::from_u64(237);
     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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_155] = [__v_32];
     record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17507,7 +17607,7 @@ fn aiur_fn_156(
     let __v_29: G = G::from_u64(240);
     let __v_30: G = G::from_u64(87);
     let __v_31: G = G::from_u64(98);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_156] = [__v_32];
     record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17556,7 +17656,7 @@ fn aiur_fn_157(
     let __v_29: G = G::from_u64(244);
     let __v_30: G = G::from_u64(198);
     let __v_31: G = G::from_u64(62);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_157] = [__v_32];
     record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17605,7 +17705,7 @@ fn aiur_fn_158(
     let __v_29: G = G::from_u64(188);
     let __v_30: G = G::from_u64(250);
     let __v_31: G = G::from_u64(236);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_158] = [__v_32];
     record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17654,7 +17754,7 @@ fn aiur_fn_159(
     let __v_29: G = G::from_u64(127);
     let __v_30: G = G::from_u64(64);
     let __v_31: G = G::from_u64(18);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_159] = [__v_32];
     record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17703,7 +17803,7 @@ fn aiur_fn_160(
     let __v_29: G = G::from_u64(169);
     let __v_30: G = G::from_u64(250);
     let __v_31: G = G::from_u64(120);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_160] = [__v_32];
     record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17752,7 +17852,7 @@ fn aiur_fn_161(
     let __v_29: G = G::from_u64(40);
     let __v_30: G = G::from_u64(229);
     let __v_31: G = G::from_u64(96);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_161] = [__v_32];
     record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17801,7 +17901,7 @@ fn aiur_fn_162(
     let __v_29: G = G::from_u64(227);
     let __v_30: G = G::from_u64(108);
     let __v_31: G = G::from_u64(113);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_162] = [__v_32];
     record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17850,7 +17950,7 @@ fn aiur_fn_163(
     let __v_29: G = G::from_u64(176);
     let __v_30: G = G::from_u64(189);
     let __v_31: G = G::from_u64(213);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_163] = [__v_32];
     record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17899,7 +17999,7 @@ fn aiur_fn_164(
     let __v_29: G = G::from_u64(220);
     let __v_30: G = G::from_u64(60);
     let __v_31: G = G::from_u64(74);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_164] = [__v_32];
     record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17948,7 +18048,7 @@ fn aiur_fn_165(
     let __v_29: G = G::from_u64(118);
     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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_165] = [__v_32];
     record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -17997,7 +18097,7 @@ fn aiur_fn_166(
     let __v_29: G = G::from_u64(113);
     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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_166] = [__v_32];
     record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -18116,8 +18216,8 @@ fn aiur_fn_168(
   unconstrained: bool,
 ) -> Result<[G; OUT_168], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(0);
-    let __v_1: G = G::from_u64(64);
+    let __v_0: G = G::from_u64(64);
+    let __v_1: G = G::from_u64(0);
     let __v_2: G = G::from_u64(0);
     let __v_3: G = G::from_u64(0);
     let __v_4: G = G::from_u64(0);
@@ -18125,15 +18225,12 @@ fn aiur_fn_168(
     let __v_6: G = G::from_u64(0);
     let __v_7: G = G::from_u64(0);
     let __v_8: G = G::from_u64(0);
-    let __v_9: G = G::from_u64(1);
-    let __v_10: G = G::from_u64(1);
-    let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_13: G = G::from_u64(7);
-    let __v_14: G = G::from_u64(0);
-    let __v_15: G = G::from_u64(0);
-    let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_168] = [__v_16];
+    let __v_9: G = { let __values: [G; 9] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_10: G = G::from_u64(7);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_168] = [__v_13];
     record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -18149,8 +18246,8 @@ fn aiur_fn_169(
   unconstrained: bool,
 ) -> Result<[G; OUT_169], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(0);
-    let __v_1: G = G::from_u64(1);
+    let __v_0: G = G::from_u64(1);
+    let __v_1: G = G::from_u64(0);
     let __v_2: G = G::from_u64(0);
     let __v_3: G = G::from_u64(0);
     let __v_4: G = G::from_u64(0);
@@ -18158,15 +18255,12 @@ fn aiur_fn_169(
     let __v_6: G = G::from_u64(0);
     let __v_7: G = G::from_u64(0);
     let __v_8: G = G::from_u64(0);
-    let __v_9: G = G::from_u64(1);
-    let __v_10: G = G::from_u64(1);
-    let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_13: G = G::from_u64(7);
-    let __v_14: G = G::from_u64(0);
-    let __v_15: G = G::from_u64(0);
-    let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_169] = [__v_16];
+    let __v_9: G = { let __values: [G; 9] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_10: G = G::from_u64(7);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_169] = [__v_13];
     record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -18256,13 +18350,13 @@ fn aiur_fn_170(
                         let __v_17: G = G::from_u64(0);
                         let __v_18: G = G::from_u64(0);
                         let __v_19: G = G::from_u64(0);
-                        let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                         let __ret: [G; OUT_170] = [__v_16, __v_20];
                         record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_1]; 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_734] = { let __args: [G; IN_734] = [__v_1]; 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_16: G = __r_arr[0];
                         let __v_17: G = G::from_u64(1);
                         let __v_18: G = { let __a_val = __v_16.as_canonical_u64(); let __b_val = __v_17.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -18272,14 +18366,14 @@ fn aiur_fn_170(
                             let __v_20: G = G::from_u64(0);
                             let __v_21: G = G::from_u64(0);
                             let __v_22: G = G::from_u64(0);
-                            let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                             let __ret: [G; OUT_170] = [__v_19, __v_23];
                             record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_19: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_19]; 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_727] = { let __args: [G; IN_727] = [__v_1, __v_19]; 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_20: G = __r_arr[0];
                             let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
                             let __v_21: G = __r_arr[0];
@@ -18327,7 +18421,7 @@ fn aiur_fn_171(
 ) -> Result<[G; OUT_171], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = G::from_u64(3);
     let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -18337,19 +18431,19 @@ fn aiur_fn_171(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_171] = [__v_4, __v_8];
         record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(2);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_4]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_4]; 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_5: G = __r_arr[0];
         let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -18374,7 +18468,7 @@ fn aiur_fn_171(
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_171] = [__v_14, __v_18];
                 record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -18386,7 +18480,7 @@ fn aiur_fn_171(
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_171] = [__v_12, __v_16];
             record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -18408,7 +18502,7 @@ fn aiur_fn_172(
 ) -> Result<[G; OUT_172], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = G::from_u64(1);
     let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -18418,19 +18512,19 @@ fn aiur_fn_172(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_172] = [__v_4, __v_8];
         record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_4]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_4]; 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_5: G = __r_arr[0];
         let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -18469,7 +18563,7 @@ fn aiur_fn_172(
                     let __v_17: G = G::from_u64(0);
                     let __v_18: G = G::from_u64(0);
                     let __v_19: G = G::from_u64(0);
-                    let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                     let __ret: [G; OUT_172] = [__v_16, __v_20];
                     record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -18483,7 +18577,7 @@ fn aiur_fn_172(
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_172] = [__v_12, __v_16];
             record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -18505,7 +18599,7 @@ fn aiur_fn_173(
 ) -> Result<[G; OUT_173], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -18527,7 +18621,7 @@ fn aiur_fn_173(
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_173] = [__v_10, __v_14];
             record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -18545,7 +18639,7 @@ fn aiur_fn_173(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_173] = [__v_5, __v_9];
         record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -18565,7 +18659,7 @@ fn aiur_fn_174(
 ) -> Result<[G; OUT_174], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -18584,7 +18678,7 @@ fn aiur_fn_174(
             let __v_6: G = G::from_u64(0);
             let __v_7: G = G::from_u64(0);
             let __v_8: G = G::from_u64(0);
-            let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_174] = [__v_5, __v_9];
             record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -18596,7 +18690,7 @@ fn aiur_fn_174(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_174] = [__v_5, __v_9];
         record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -18647,7 +18741,7 @@ fn aiur_fn_175(
     let __v_29: G = G::from_u64(74);
     let __v_30: G = G::from_u64(183);
     let __v_31: G = G::from_u64(191);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_175] = [__v_32];
     record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -18696,7 +18790,7 @@ fn aiur_fn_176(
     let __v_29: G = G::from_u64(255);
     let __v_30: G = G::from_u64(191);
     let __v_31: G = G::from_u64(133);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_176] = [__v_32];
     record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -18745,7 +18839,7 @@ fn aiur_fn_177(
     let __v_29: G = G::from_u64(111);
     let __v_30: G = G::from_u64(11);
     let __v_31: G = G::from_u64(90);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_177] = [__v_32];
     record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -18794,7 +18888,7 @@ fn aiur_fn_178(
     let __v_29: G = G::from_u64(114);
     let __v_30: G = G::from_u64(108);
     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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_178] = [__v_32];
     record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -18843,7 +18937,7 @@ fn aiur_fn_179(
     let __v_29: G = G::from_u64(115);
     let __v_30: G = G::from_u64(55);
     let __v_31: G = G::from_u64(35);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_179] = [__v_32];
     record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -18892,7 +18986,7 @@ fn aiur_fn_180(
     let __v_29: G = G::from_u64(61);
     let __v_30: G = G::from_u64(51);
     let __v_31: G = G::from_u64(18);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_180] = [__v_32];
     record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -18975,12 +19069,10 @@ fn aiur_fn_182(
         let __v_1: G = G::from_u64(2);
         let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } else { aiur_fn_157(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_182] = [__v_7];
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = { let __values: [G; 4] = [__v_1, __v_2, __v_3, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_182] = [__v_5];
         record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -18988,12 +19080,10 @@ fn aiur_fn_182(
         let __v_1: G = G::from_u64(2);
         let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_182] = [__v_7];
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = { let __values: [G; 4] = [__v_1, __v_2, __v_3, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_182] = [__v_5];
         record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -19020,10 +19110,8 @@ fn aiur_fn_183(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_183] = [__v_5, __v_8];
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_183] = [__v_5, __v_6];
         record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -19034,10 +19122,8 @@ fn aiur_fn_183(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_7: G = G::from_u64(0);
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_183] = [__v_7, __v_10];
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_183] = [__v_7, __v_8];
             record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -19048,16 +19134,14 @@ fn aiur_fn_183(
             match __v_7.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __v_10: G = G::from_u64(1);
-                let __v_11: G = G::from_u64(1);
-                let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_183] = [__v_9, __v_12];
+                let __v_10: G = G::from_u64(0);
+                let __ret: [G; OUT_183] = [__v_9, __v_10];
                 record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __v_9: G = G::from_u64(0);
-                let __v_10: G = G::from_u64(2);
+                let __v_9: G = G::from_u64(2);
+                let __v_10: G = G::from_u64(0);
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
@@ -19065,18 +19149,15 @@ fn aiur_fn_183(
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
-                let __v_18: G = G::from_u64(1);
-                let __v_19: G = G::from_u64(1);
-                let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_21: G = { let __values: [G; 10] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_21, __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_18: G = { let __values: [G; 9] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_18, __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_19: G = __r_arr[0];
+                let __v_20: G = G::from_u64(1);
+                let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_6, __v_19]; 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_21: G = __r_arr[0];
+                let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_21]; 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_22: G = __r_arr[0];
-                let __v_23: G = G::from_u64(1);
-                let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_6, __v_22]; 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_24: G = __r_arr[0];
-                let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
-                let __v_25: G = __r_arr[0];
-                let __ret: [G; OUT_183] = [__v_23, __v_25];
+                let __ret: [G; OUT_183] = [__v_20, __v_22];
                 record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -19108,7 +19189,7 @@ fn aiur_fn_184(
 ) -> Result<[G; OUT_184], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = G::from_u64(3);
     let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -19118,20 +19199,20 @@ fn aiur_fn_184(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_184] = [__v_4, __v_8];
         record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_4]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_4]; 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_5: G = __r_arr[0];
         let __v_6: G = G::from_u64(1);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(2);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
@@ -19142,7 +19223,7 @@ fn aiur_fn_184(
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_184] = [__v_12, __v_16];
             record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -19157,7 +19238,7 @@ fn aiur_fn_184(
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_184] = [__v_14, __v_18];
                 record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -19199,7 +19280,7 @@ fn aiur_fn_185(
 ) -> Result<[G; OUT_185], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = G::from_u64(2);
     let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -19209,19 +19290,19 @@ fn aiur_fn_185(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_185] = [__v_4, __v_8];
         record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_4]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_4]; 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_5: G = __r_arr[0];
         let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -19238,13 +19319,13 @@ fn aiur_fn_185(
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_185] = [__v_14, __v_18];
                 record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_7]; 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_734] = { let __args: [G; IN_734] = [__v_7]; 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 = G::from_u64(4);
                 let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -19254,19 +19335,19 @@ fn aiur_fn_185(
                     let __v_18: G = G::from_u64(0);
                     let __v_19: G = G::from_u64(0);
                     let __v_20: G = G::from_u64(0);
-                    let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                     let __ret: [G; OUT_185] = [__v_17, __v_21];
                     record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_17: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_7, __v_17]; 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_727] = { let __args: [G; IN_727] = [__v_7, __v_17]; 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_18: G = __r_arr[0];
                     let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_18]; 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_19: G = __r_arr[0];
                     let __v_20: G = __r_arr[1];
-                    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                     let __v_21: G = __loaded[0];
                     let __v_22: G = __loaded[1];
                     let __v_23: G = __loaded[2];
@@ -19283,13 +19364,13 @@ fn aiur_fn_185(
                             let __v_28: G = G::from_u64(0);
                             let __v_29: G = G::from_u64(0);
                             let __v_30: G = G::from_u64(0);
-                            let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                             let __ret: [G; OUT_185] = [__v_27, __v_31];
                             record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_20]; 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_734] = { let __args: [G; IN_734] = [__v_20]; 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_27: G = __r_arr[0];
                             let __v_28: G = G::from_u64(1);
                             let __v_29: G = { let __a_val = __v_27.as_canonical_u64(); let __b_val = __v_28.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -19299,34 +19380,29 @@ fn aiur_fn_185(
                                 let __v_31: G = G::from_u64(0);
                                 let __v_32: G = G::from_u64(0);
                                 let __v_33: G = G::from_u64(0);
-                                let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                 let __ret: [G; OUT_185] = [__v_30, __v_34];
                                 record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_30: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_20, __v_30]; 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_727] = { let __args: [G; IN_727] = [__v_20, __v_30]; 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_31: G = __r_arr[0];
                                 let __v_32: G = G::from_u64(2);
-                                let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_7, __v_32]; 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_727] = { let __args: [G; IN_727] = [__v_7, __v_32]; 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_33: G = __r_arr[0];
                                 let __v_34: G = G::from_u64(3);
-                                let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_7, __v_34]; 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_727] = { let __args: [G; IN_727] = [__v_7, __v_34]; 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_35: G = __r_arr[0];
                                 let __v_36: G = G::from_u64(0);
-                                let __v_37: G = G::from_u64(0);
-                                let __v_38: G = G::from_u64(0);
-                                let __v_39: G = G::from_u64(1);
-                                let __v_40: G = G::from_u64(1);
-                                let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_44]; 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_45: G = __r_arr[0];
-                                let __v_46: G = __r_arr[1];
-                                let __ret: [G; OUT_185] = [__v_45, __v_46];
+                                let __v_37: G = { let __values: [G; 2] = [__v_35, __v_36]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_38: G = { let __values: [G; 2] = [__v_33, __v_37]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_39: G = { let __values: [G; 2] = [__v_31, __v_38]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_39]; 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_40: G = __r_arr[0];
+                                let __v_41: G = __r_arr[1];
+                                let __ret: [G; OUT_185] = [__v_40, __v_41];
                                 record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
@@ -19339,7 +19415,7 @@ fn aiur_fn_185(
                         let __v_26: G = G::from_u64(0);
                         let __v_27: G = G::from_u64(0);
                         let __v_28: G = G::from_u64(0);
-                        let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                         let __ret: [G; OUT_185] = [__v_25, __v_29];
                         record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
@@ -19355,7 +19431,7 @@ fn aiur_fn_185(
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_185] = [__v_12, __v_16];
             record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -19380,7 +19456,7 @@ fn aiur_fn_186(
     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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -19393,7 +19469,7 @@ fn aiur_fn_186(
         let __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_2]; 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_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 __v_9: G = __r_arr[0];
             let __v_10: G = G::from_u64(2);
             let __v_11: G = (__v_9 - __v_10);
@@ -19401,10 +19477,10 @@ fn aiur_fn_186(
               0u64 => {
                 let __v_12: G = G::from_u64(1);
                 let __v_13: G = G::from_u64(0);
-                let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_13]; 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_727] = { let __args: [G; IN_727] = [__v_2, __v_13]; 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_14: G = __r_arr[0];
                 let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_15]; 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_727] = { let __args: [G; IN_727] = [__v_2, __v_15]; 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_16: G = __r_arr[0];
                 let __ret: [G; OUT_186] = [__v_12, __v_14, __v_16];
                 record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -19415,11 +19491,11 @@ fn aiur_fn_186(
                 let __v_13: G = G::from_u64(0);
                 let __v_14: G = G::from_u64(0);
                 let __v_15: G = G::from_u64(0);
-                let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_17: G = G::from_u64(0);
                 let __v_18: G = G::from_u64(0);
                 let __v_19: G = G::from_u64(0);
-                let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_186] = [__v_12, __v_16, __v_20];
                 record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -19431,11 +19507,11 @@ fn aiur_fn_186(
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
             let __v_16: G = G::from_u64(0);
-            let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_186] = [__v_9, __v_13, __v_17];
             record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -19447,11 +19523,11 @@ fn aiur_fn_186(
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_12: G = G::from_u64(0);
         let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_186] = [__v_7, __v_11, __v_15];
         record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -19479,7 +19555,7 @@ fn aiur_fn_187(
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_1]; 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_734] = { let __args: [G; IN_734] = [__v_1]; 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_5: G = __r_arr[0];
         let __v_6: G = G::from_u64(2);
         let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -19489,7 +19565,7 @@ fn aiur_fn_187(
             let __v_9: G = G::from_u64(0);
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(0);
-            let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_187] = [__v_8, __v_12];
             record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -19498,10 +19574,10 @@ fn aiur_fn_187(
             let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } else { aiur_fn_361(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_8, __v_9]; 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_727] = { let __args: [G; IN_727] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(1);
-            let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_8, __v_11]; 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_12: G = __r_arr[0];
             let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_10, __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_13: G = __r_arr[0];
@@ -19512,7 +19588,7 @@ fn aiur_fn_187(
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
                 let __v_18: G = G::from_u64(0);
-                let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_187] = [__v_15, __v_19];
                 record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -19567,7 +19643,7 @@ fn aiur_fn_187(
                 let __v_10: G = G::from_u64(0);
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
-                let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_187] = [__v_9, __v_13];
                 record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -19594,66 +19670,51 @@ fn aiur_fn_188(
     let __v_1: G = inp[1];
     let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
+    match __v_2.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_188] = [__v_2];
         record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        match __v_4.as_canonical_u64() {
+          0u64 => {
             let __ret: [G; OUT_188] = [__v_2];
             record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_9: G = __loaded[0];
-            let __v_10: G = __loaded[1];
-            let __v_11: G = __loaded[2];
-            match __v_9.as_canonical_u64() {
-              1u64 => {
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_5: G = __loaded[0];
+            let __v_6: G = __loaded[1];
+            match __v_6.as_canonical_u64() {
+              0u64 => {
                 let __ret: [G; OUT_188] = [__v_2];
                 record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
-              0u64 => {
+              _ => {
+                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                let __v_7: G = __loaded[0];
+                let __v_8: G = __loaded[1];
+                let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
                 let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-                let __v_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-                let __v_13: G = __r_arr[0];
-                let __v_14: G = G::from_u64(0);
-                let __v_15: G = G::from_u64(0);
-                let __v_16: G = G::from_u64(0);
-                let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_188] = [__v_19];
+                let __v_10: G = __r_arr[0];
+                let __v_11: G = { let __values: [G; 2] = [__v_10, __v_8]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_12: G = { let __values: [G; 2] = [__v_9, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_13: G = { let __values: [G; 2] = [__v_3, __v_12]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_188] = [__v_13];
                 record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-              },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -19725,7 +19786,7 @@ fn aiur_fn_190(
     let __v_29: G = G::from_u64(33);
     let __v_30: G = G::from_u64(221);
     let __v_31: G = G::from_u64(233);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_190] = [__v_32];
     record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -19774,7 +19835,7 @@ fn aiur_fn_191(
     let __v_29: G = G::from_u64(82);
     let __v_30: G = G::from_u64(179);
     let __v_31: G = G::from_u64(139);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_191] = [__v_32];
     record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -19823,7 +19884,7 @@ fn aiur_fn_192(
     let __v_29: G = G::from_u64(84);
     let __v_30: G = G::from_u64(36);
     let __v_31: G = G::from_u64(45);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_192] = [__v_32];
     record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -19872,7 +19933,7 @@ fn aiur_fn_193(
     let __v_29: G = G::from_u64(49);
     let __v_30: G = G::from_u64(134);
     let __v_31: G = G::from_u64(9);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_193] = [__v_32];
     record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -19921,7 +19982,7 @@ fn aiur_fn_194(
     let __v_29: G = G::from_u64(239);
     let __v_30: G = G::from_u64(202);
     let __v_31: G = G::from_u64(62);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_194] = [__v_32];
     record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -19970,7 +20031,7 @@ fn aiur_fn_195(
     let __v_29: G = G::from_u64(53);
     let __v_30: G = G::from_u64(2);
     let __v_31: G = G::from_u64(160);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_195] = [__v_32];
     record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -20019,7 +20080,7 @@ fn aiur_fn_196(
     let __v_29: G = G::from_u64(179);
     let __v_30: G = G::from_u64(94);
     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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_196] = [__v_32];
     record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -20068,7 +20129,7 @@ fn aiur_fn_197(
     let __v_29: G = G::from_u64(71);
     let __v_30: G = G::from_u64(201);
     let __v_31: G = G::from_u64(53);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_197] = [__v_32];
     record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -20117,7 +20178,7 @@ fn aiur_fn_198(
     let __v_29: G = G::from_u64(137);
     let __v_30: G = G::from_u64(224);
     let __v_31: G = G::from_u64(224);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_198] = [__v_32];
     record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -20166,7 +20227,7 @@ fn aiur_fn_199(
     let __v_29: G = G::from_u64(5);
     let __v_30: G = G::from_u64(74);
     let __v_31: G = G::from_u64(106);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_199] = [__v_32];
     record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -20215,7 +20276,7 @@ fn aiur_fn_200(
     let __v_29: G = G::from_u64(243);
     let __v_30: G = G::from_u64(174);
     let __v_31: G = G::from_u64(240);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_200] = [__v_32];
     record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -20264,7 +20325,7 @@ fn aiur_fn_201(
     let __v_29: G = G::from_u64(106);
     let __v_30: G = G::from_u64(175);
     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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_201] = [__v_32];
     record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -20313,7 +20374,7 @@ fn aiur_fn_202(
     let __v_29: G = G::from_u64(209);
     let __v_30: G = G::from_u64(145);
     let __v_31: G = G::from_u64(247);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_202] = [__v_32];
     record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -20449,7 +20510,7 @@ fn aiur_fn_204(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_1]; 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_734] = { let __args: [G; IN_734] = [__v_1]; 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_3: G = __r_arr[0];
     let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
@@ -20460,7 +20521,7 @@ fn aiur_fn_204(
         match __v_3.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(0);
-            let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_7, __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 __v_8: G = __r_arr[0];
@@ -20471,7 +20532,7 @@ fn aiur_fn_204(
                 let __v_11: G = G::from_u64(7);
                 let __v_12: G = G::from_u64(1);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_204] = [__v_10, __v_14];
                 record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -20481,7 +20542,7 @@ fn aiur_fn_204(
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_204] = [__v_10, __v_14];
                 record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -20496,7 +20557,7 @@ fn aiur_fn_204(
             let __v_7: G = G::from_u64(0);
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(0);
-            let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_204] = [__v_6, __v_10];
             record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -20518,16 +20579,16 @@ fn aiur_fn_204(
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_204] = [__v_10, __v_14];
                 record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_10]; 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_727] = { let __args: [G; IN_727] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                 let __v_12: G = __loaded[0];
                 let __v_13: G = __loaded[1];
                 let __v_14: G = __loaded[2];
@@ -20536,7 +20597,7 @@ fn aiur_fn_204(
                   7u64 => {
                     match __v_13.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_14]; 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_734] = { let __args: [G; IN_734] = [__v_14]; 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_16: G = __r_arr[0];
                         let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
                         let __v_17: G = __r_arr[0];
@@ -20546,7 +20607,7 @@ fn aiur_fn_204(
                         let __v_20: G = G::from_u64(7);
                         let __v_21: G = G::from_u64(0);
                         let __v_22: G = G::from_u64(0);
-                        let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_18, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_18, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                         let __ret: [G; OUT_204] = [__v_19, __v_23];
                         record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
@@ -20556,7 +20617,7 @@ fn aiur_fn_204(
                         let __v_17: G = G::from_u64(0);
                         let __v_18: G = G::from_u64(0);
                         let __v_19: G = G::from_u64(0);
-                        let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                         let __ret: [G; OUT_204] = [__v_16, __v_20];
                         record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
@@ -20568,7 +20629,7 @@ fn aiur_fn_204(
                     let __v_17: G = G::from_u64(0);
                     let __v_18: G = G::from_u64(0);
                     let __v_19: G = G::from_u64(0);
-                    let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                     let __ret: [G; OUT_204] = [__v_16, __v_20];
                     record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -20648,19 +20709,19 @@ fn aiur_fn_204(
                                     let __v_21: G = G::from_u64(0);
                                     let __v_22: G = G::from_u64(0);
                                     let __v_23: G = G::from_u64(0);
-                                    let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                     let __ret: [G; OUT_204] = [__v_20, __v_24];
                                     record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
                                     let __v_20: G = G::from_u64(0);
-                                    let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_20]; 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_727] = { let __args: [G; IN_727] = [__v_1, __v_20]; 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_21: G = __r_arr[0];
                                     let __v_22: G = G::from_u64(1);
-                                    let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_22]; 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_727] = { let __args: [G; IN_727] = [__v_1, __v_22]; 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_23: G = __r_arr[0];
-                                    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                                    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                                     let __v_24: G = __loaded[0];
                                     let __v_25: G = __loaded[1];
                                     let __v_26: G = __loaded[2];
@@ -20669,7 +20730,7 @@ fn aiur_fn_204(
                                       7u64 => {
                                         match __v_25.as_canonical_u64() {
                                           1u64 => {
-                                            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                                            let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                                             let __v_28: G = __loaded[0];
                                             let __v_29: G = __loaded[1];
                                             let __v_30: G = __loaded[2];
@@ -20678,13 +20739,13 @@ fn aiur_fn_204(
                                               7u64 => {
                                                 match __v_29.as_canonical_u64() {
                                                   1u64 => {
-                                                    let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } };
                                                     let __v_32: G = __r_arr[0];
                                                     let __v_33: G = G::from_u64(1);
                                                     let __v_34: G = G::from_u64(7);
                                                     let __v_35: G = G::from_u64(1);
                                                     let __v_36: G = G::from_u64(0);
-                                                    let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                    let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                                     let __ret: [G; OUT_204] = [__v_33, __v_37];
                                                     record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
@@ -20694,7 +20755,7 @@ fn aiur_fn_204(
                                                     let __v_33: G = G::from_u64(0);
                                                     let __v_34: G = G::from_u64(0);
                                                     let __v_35: G = G::from_u64(0);
-                                                    let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                                     let __ret: [G; OUT_204] = [__v_32, __v_36];
                                                     record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
@@ -20706,7 +20767,7 @@ fn aiur_fn_204(
                                                 let __v_33: G = G::from_u64(0);
                                                 let __v_34: G = G::from_u64(0);
                                                 let __v_35: G = G::from_u64(0);
-                                                let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                                 let __ret: [G; OUT_204] = [__v_32, __v_36];
                                                 record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
@@ -20718,7 +20779,7 @@ fn aiur_fn_204(
                                             let __v_29: G = G::from_u64(0);
                                             let __v_30: G = G::from_u64(0);
                                             let __v_31: G = G::from_u64(0);
-                                            let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                             let __ret: [G; OUT_204] = [__v_28, __v_32];
                                             record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
@@ -20730,7 +20791,7 @@ fn aiur_fn_204(
                                         let __v_29: G = G::from_u64(0);
                                         let __v_30: G = G::from_u64(0);
                                         let __v_31: G = G::from_u64(0);
-                                        let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                         let __ret: [G; OUT_204] = [__v_28, __v_32];
                                         record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
@@ -20744,7 +20805,7 @@ fn aiur_fn_204(
                                 let __v_19: G = G::from_u64(0);
                                 let __v_20: G = G::from_u64(0);
                                 let __v_21: G = G::from_u64(0);
-                                let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                 let __ret: [G; OUT_204] = [__v_18, __v_22];
                                 record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
@@ -20776,7 +20837,7 @@ fn aiur_fn_205(
 ) -> Result<[G; OUT_205], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = G::from_u64(1);
     let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -20786,16 +20847,16 @@ fn aiur_fn_205(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_205] = [__v_4, __v_8];
         record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_4]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_4]; 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_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -20811,20 +20872,18 @@ fn aiur_fn_205(
                 let __v_12: G = G::from_u64(7);
                 let __v_13: G = G::from_u64(0);
                 let __v_14: G = G::from_u64(0);
-                let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_16: G = G::from_u64(2);
                 let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
                 let __v_17: G = __r_arr[0];
-                let __v_18: G = G::from_u64(1);
-                let __v_19: G = G::from_u64(1);
-                let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_21: G = G::from_u64(0);
-                let __v_22: G = { let __values: [G; 4] = [__v_16, __v_17, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_23: G = G::from_u64(1);
-                let __v_24: G = G::from_u64(3);
-                let __v_25: G = G::from_u64(0);
-                let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_205] = [__v_23, __v_26];
+                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_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_21: G = G::from_u64(1);
+                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_20, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_205] = [__v_21, __v_24];
                 record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -20833,7 +20892,7 @@ fn aiur_fn_205(
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_205] = [__v_10, __v_14];
                 record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -20845,7 +20904,7 @@ fn aiur_fn_205(
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_205] = [__v_10, __v_14];
             record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -20867,7 +20926,7 @@ fn aiur_fn_206(
 ) -> Result<[G; OUT_206], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = G::from_u64(1);
     let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -20877,16 +20936,16 @@ fn aiur_fn_206(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_206] = [__v_4, __v_8];
         record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_4]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_4]; 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_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -20895,32 +20954,26 @@ fn aiur_fn_206(
           7u64 => {
             match __v_7.as_canonical_u64() {
               1u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                let __v_10: G = __loaded[0];
-                let __v_11: G = __loaded[1];
-                let __v_12: G = __loaded[2];
-                match __v_10.as_canonical_u64() {
-                  1u64 => {
-                    let __v_13: G = G::from_u64(1);
-                    let __v_14: G = G::from_u64(2);
+                match __v_8.as_canonical_u64() {
+                  0u64 => {
+                    let __v_10: G = G::from_u64(1);
+                    let __v_11: G = G::from_u64(2);
                     let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } };
-                    let __v_15: G = __r_arr[0];
-                    let __v_16: G = G::from_u64(1);
-                    let __v_17: G = G::from_u64(1);
-                    let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_19: G = G::from_u64(0);
-                    let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_206] = [__v_13, __v_20];
+                    let __v_12: G = __r_arr[0];
+                    let __v_13: G = G::from_u64(0);
+                    let __v_14: G = G::from_u64(0);
+                    let __v_15: G = { let __values: [G; 4] = [__v_11, __v_12, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __ret: [G; OUT_206] = [__v_10, __v_15];
                     record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
+                    let __v_10: G = G::from_u64(0);
+                    let __v_11: G = G::from_u64(0);
+                    let __v_12: G = G::from_u64(0);
                     let __v_13: G = G::from_u64(0);
-                    let __v_14: G = G::from_u64(0);
-                    let __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_206] = [__v_13, __v_17];
+                    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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __ret: [G; OUT_206] = [__v_10, __v_14];
                     record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
@@ -20931,7 +20984,7 @@ fn aiur_fn_206(
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_206] = [__v_10, __v_14];
                 record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -20943,7 +20996,7 @@ fn aiur_fn_206(
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_206] = [__v_10, __v_14];
             record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -20965,28 +21018,24 @@ fn aiur_fn_207(
 ) -> Result<[G; OUT_207], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_207] = [];
         record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
         let __ret: [G; OUT_207] = [];
         record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -21023,29 +21072,25 @@ fn aiur_fn_209(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_209] = [__v_1];
         record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = __r_arr[1];
-        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_6, __v_5]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_209] = [__v_7];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_209] = [__v_6];
         record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -21116,25 +21161,31 @@ fn aiur_fn_211(
             let __v_7: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_6) } else { bytes2_less_than_value(__v_0, __v_6, record) };
             match __v_7.as_canonical_u64() {
               1u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                let __v_8: G = __loaded[0];
-                let __v_9: G = __loaded[1];
-                let __v_10: G = __loaded[2];
-                match __v_8.as_canonical_u64() {
+                match __v_1.as_canonical_u64() {
                   0u64 => {
-                    let __v_11: G = G::from_u64(192);
-                    let __v_12: G = (__v_0 - __v_11);
-                    let __v_13: G = G::from_u64(64);
-                    let __v_14: G = (__v_12 * __v_13);
-                    let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
-                    let __v_15: G = __r_arr[0];
-                    let __v_16: G = (__v_14 + __v_15);
-                    let __ret: [G; OUT_211] = [__v_16, __v_10];
+                    let __v_8: G = G::from_u64(0);
+                    let __v_9: G = G::from_u64(1);
+                    if (__v_8 != __v_9) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                    }
+                    let __ret: [G; OUT_211] = [__v_8, __v_8];
                     record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                    let __v_8: G = __loaded[0];
+                    let __v_9: G = __loaded[1];
+                    let __v_10: G = G::from_u64(192);
+                    let __v_11: G = (__v_0 - __v_10);
+                    let __v_12: G = G::from_u64(64);
+                    let __v_13: G = (__v_11 * __v_12);
+                    let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
+                    let __v_14: G = __r_arr[0];
+                    let __v_15: G = (__v_13 + __v_14);
+                    let __ret: [G; OUT_211] = [__v_15, __v_9];
+                    record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
                 }
               },
@@ -21143,115 +21194,145 @@ fn aiur_fn_211(
                 let __v_9: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_8) } else { bytes2_less_than_value(__v_0, __v_8, record) };
                 match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                    let __v_10: G = __loaded[0];
-                    let __v_11: G = __loaded[1];
-                    let __v_12: G = __loaded[2];
-                    match __v_10.as_canonical_u64() {
+                    match __v_1.as_canonical_u64() {
                       0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                        let __v_13: G = __loaded[0];
-                        let __v_14: G = __loaded[1];
-                        let __v_15: G = __loaded[2];
-                        match __v_13.as_canonical_u64() {
+                        let __v_10: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                        }
+                        let __ret: [G; OUT_211] = [__v_10, __v_10];
+                        record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                        let __v_10: G = __loaded[0];
+                        let __v_11: G = __loaded[1];
+                        match __v_11.as_canonical_u64() {
                           0u64 => {
-                            let __v_16: G = G::from_u64(224);
-                            let __v_17: G = (__v_0 - __v_16);
-                            let __v_18: G = G::from_u64(4096);
-                            let __v_19: G = (__v_17 * __v_18);
-                            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
-                            let __v_20: G = __r_arr[0];
-                            let __v_21: G = G::from_u64(64);
-                            let __v_22: G = (__v_20 * __v_21);
-                            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_14]; 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_23: G = __r_arr[0];
-                            let __v_24: G = (__v_22 + __v_23);
-                            let __v_25: G = (__v_19 + __v_24);
-                            let __v_26: G = G::from_u64(2048);
-                            let __v_27: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_26.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                            match __v_27.as_canonical_u64() {
+                            let __v_12: G = G::from_u64(0);
+                            let __v_13: G = G::from_u64(1);
+                            if (__v_12 != __v_13) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                            }
+                            let __ret: [G; OUT_211] = [__v_12, __v_12];
+                            record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                            let __v_12: G = __loaded[0];
+                            let __v_13: G = __loaded[1];
+                            let __v_14: G = G::from_u64(224);
+                            let __v_15: G = (__v_0 - __v_14);
+                            let __v_16: G = G::from_u64(4096);
+                            let __v_17: G = (__v_15 * __v_16);
+                            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_10]; 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_18: G = __r_arr[0];
+                            let __v_19: G = G::from_u64(64);
+                            let __v_20: G = (__v_18 * __v_19);
+                            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
+                            let __v_21: G = __r_arr[0];
+                            let __v_22: G = (__v_20 + __v_21);
+                            let __v_23: G = (__v_17 + __v_22);
+                            let __v_24: G = G::from_u64(2048);
+                            let __v_25: G = { let __a_val = __v_23.as_canonical_u64(); let __b_val = __v_24.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                            match __v_25.as_canonical_u64() {
                               0u64 => {
-                                let __ret: [G; OUT_211] = [__v_25, __v_15];
+                                let __ret: [G; OUT_211] = [__v_23, __v_13];
                                 record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
-                                return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64()));
+                                return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
                               },
                             }
                           },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-                          },
                         }
                       },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-                      },
                     }
                   },
                   _ => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                    let __v_10: G = __loaded[0];
-                    let __v_11: G = __loaded[1];
-                    let __v_12: G = __loaded[2];
-                    match __v_10.as_canonical_u64() {
+                    match __v_1.as_canonical_u64() {
                       0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                        let __v_13: G = __loaded[0];
-                        let __v_14: G = __loaded[1];
-                        let __v_15: G = __loaded[2];
-                        match __v_13.as_canonical_u64() {
+                        let __v_10: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                        }
+                        let __ret: [G; OUT_211] = [__v_10, __v_10];
+                        record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                        let __v_10: G = __loaded[0];
+                        let __v_11: G = __loaded[1];
+                        match __v_11.as_canonical_u64() {
                           0u64 => {
-                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                            let __v_16: G = __loaded[0];
-                            let __v_17: G = __loaded[1];
-                            let __v_18: G = __loaded[2];
-                            match __v_16.as_canonical_u64() {
+                            let __v_12: G = G::from_u64(0);
+                            let __v_13: G = G::from_u64(1);
+                            if (__v_12 != __v_13) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                            }
+                            let __ret: [G; OUT_211] = [__v_12, __v_12];
+                            record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                            let __v_12: G = __loaded[0];
+                            let __v_13: G = __loaded[1];
+                            match __v_13.as_canonical_u64() {
                               0u64 => {
-                                let __v_19: G = G::from_u64(240);
-                                let __v_20: G = (__v_0 - __v_19);
-                                let __v_21: G = G::from_u64(262144);
+                                let __v_14: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                }
+                                let __ret: [G; OUT_211] = [__v_14, __v_14];
+                                record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                let __v_14: G = __loaded[0];
+                                let __v_15: G = __loaded[1];
+                                let __v_16: G = G::from_u64(240);
+                                let __v_17: G = (__v_0 - __v_16);
+                                let __v_18: G = G::from_u64(262144);
+                                let __v_19: G = (__v_17 * __v_18);
+                                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_10]; 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_20: G = __r_arr[0];
+                                let __v_21: G = G::from_u64(4096);
                                 let __v_22: G = (__v_20 * __v_21);
-                                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_12]; 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_23: G = __r_arr[0];
-                                let __v_24: G = G::from_u64(4096);
+                                let __v_24: G = G::from_u64(64);
                                 let __v_25: G = (__v_23 * __v_24);
                                 let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_14]; 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_26: G = __r_arr[0];
-                                let __v_27: G = G::from_u64(64);
-                                let __v_28: G = (__v_26 * __v_27);
-                                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_17]; 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_29: G = __r_arr[0];
-                                let __v_30: G = (__v_28 + __v_29);
-                                let __v_31: G = (__v_25 + __v_30);
-                                let __v_32: G = (__v_22 + __v_31);
-                                let __v_33: G = G::from_u64(65536);
-                                let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                                match __v_34.as_canonical_u64() {
+                                let __v_27: G = (__v_25 + __v_26);
+                                let __v_28: G = (__v_22 + __v_27);
+                                let __v_29: G = (__v_19 + __v_28);
+                                let __v_30: G = G::from_u64(65536);
+                                let __v_31: G = { let __a_val = __v_29.as_canonical_u64(); let __b_val = __v_30.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_31.as_canonical_u64() {
                                   0u64 => {
-                                    let __ret: [G; OUT_211] = [__v_32, __v_18];
+                                    let __ret: [G; OUT_211] = [__v_29, __v_15];
                                     record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
-                                    return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
+                                    return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
                                   },
                                 }
                               },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-                              },
                             }
                           },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-                          },
                         }
                       },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-                      },
                     }
                   },
                 }
@@ -21280,58 +21361,49 @@ fn aiur_fn_212(
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
     let __v_2: G = G::from_u64(0);
-    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_4: G = G::from_u64(0);
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = G::from_u64(1);
-    let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_9: G = G::from_u64(2);
+    let __v_5: G = { let __values: [G; 2] = [__v_3, __v_4]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_6: G = G::from_u64(2);
     let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __v_11: G = G::from_u64(0);
-    let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_13: G = G::from_u64(2);
+    let __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_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_10: G = G::from_u64(2);
     let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
-    let __v_14: G = __r_arr[0];
-    let __v_15: G = G::from_u64(0);
-    let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_17: G = G::from_u64(2);
+    let __v_11: G = __r_arr[0];
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_5, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_14: G = G::from_u64(2);
     let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-    let __v_18: G = __r_arr[0];
-    let __v_19: G = G::from_u64(1);
-    let __v_20: G = G::from_u64(1);
-    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_15: G = __r_arr[0];
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = G::from_u64(0);
+    let __v_18: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_19: G = G::from_u64(2);
+    let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+    let __v_20: G = __r_arr[0];
+    let __v_21: G = G::from_u64(0);
     let __v_22: G = G::from_u64(0);
-    let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_23: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_24: G = G::from_u64(2);
-    let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
-    let __v_25: G = __r_arr[0];
-    let __v_26: G = G::from_u64(1);
-    let __v_27: G = G::from_u64(1);
-    let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_29: G = G::from_u64(0);
-    let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_31: G = G::from_u64(2);
     let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-    let __v_32: G = __r_arr[0];
-    let __v_33: G = G::from_u64(1);
-    let __v_34: G = G::from_u64(1);
-    let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_36: G = G::from_u64(0);
-    let __v_37: G = { let __values: [G; 4] = [__v_31, __v_32, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_38: G = G::from_u64(3);
-    let __v_39: G = G::from_u64(0);
-    let __v_40: G = { let __values: [G; 4] = [__v_38, __v_12, __v_23, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_41: G = G::from_u64(3);
-    let __v_42: G = G::from_u64(0);
-    let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_40, __v_43, __v_30]; 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_44: G = __r_arr[0];
-    let __v_45: G = G::from_u64(3);
-    let __v_46: G = G::from_u64(0);
-    let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_212] = [__v_47];
+    let __v_25: G = __r_arr[0];
+    let __v_26: G = G::from_u64(0);
+    let __v_27: G = G::from_u64(0);
+    let __v_28: G = { let __values: [G; 4] = [__v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    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_9, __v_18, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = G::from_u64(3);
+    let __v_33: G = G::from_u64(0);
+    let __v_34: G = { let __values: [G; 4] = [__v_32, __v_13, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_31, __v_34, __v_23]; 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_35: G = __r_arr[0];
+    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_28, __v_35, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_212] = [__v_38];
     record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -21351,44 +21423,40 @@ fn aiur_fn_213(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_213] = [__v_1];
         record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __v_10: G = G::from_u64(7);
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = G::from_u64(7);
+        let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_14: G = G::from_u64(3);
-        let __v_15: G = G::from_u64(0);
-        let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_17: G = G::from_u64(3);
-        let __v_18: G = G::from_u64(0);
-        let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __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 __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_213] = [__v_23];
+        let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = G::from_u64(3);
+        let __v_14: G = G::from_u64(0);
+        let __v_15: G = { let __values: [G; 4] = [__v_13, __v_3, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_16: G = G::from_u64(3);
+        let __v_17: G = G::from_u64(0);
+        let __v_18: G = { let __values: [G; 4] = [__v_16, __v_2, __v_15, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_7, __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 __v_19: G = __r_arr[0];
+        let __v_20: G = G::from_u64(3);
+        let __v_21: G = G::from_u64(0);
+        let __v_22: G = { let __values: [G; 4] = [__v_20, __v_18, __v_19, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_213] = [__v_22];
         record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
     }
   })
 }
@@ -21405,14 +21473,14 @@ fn aiur_fn_214(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -21421,7 +21489,7 @@ fn aiur_fn_214(
           2u64 => {
             let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_11: G = __loaded[0];
             let __v_12: G = __loaded[1];
             let __v_13: G = __loaded[2];
@@ -21436,34 +21504,32 @@ fn aiur_fn_214(
             let __v_22: G = __loaded[11];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __v_23: G = G::from_u64(1);
-                let __v_24: G = G::from_u64(1);
-                let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_14, __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 __v_26: G = __r_arr[0];
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-                let __v_27: G = __loaded[0];
-                let __v_28: G = __loaded[1];
-                let __v_29: G = __loaded[2];
-                let __v_30: G = __loaded[3];
-                match __v_27.as_canonical_u64() {
+                let __v_23: G = G::from_u64(0);
+                let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_14, __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 __v_24: G = __r_arr[0];
+                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                let __v_25: G = __loaded[0];
+                let __v_26: G = __loaded[1];
+                let __v_27: G = __loaded[2];
+                let __v_28: G = __loaded[3];
+                match __v_25.as_canonical_u64() {
                   4u64 => {
-                    let __v_31: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_29, __v_4, __v_31]; 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_32: G = __r_arr[0];
-                    let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } };
-                    let __v_33: G = __r_arr[0];
-                    let __ret: [G; OUT_214] = [__v_33];
+                    let __v_29: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_27, __v_4, __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 __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } };
+                    let __v_31: G = __r_arr[0];
+                    let __ret: [G; OUT_214] = [__v_31];
                     record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __v_31: G = G::from_u64(3);
-                    let __v_32: G = G::from_u64(0);
-                    let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } };
-                    let __v_34: G = __r_arr[0];
-                    let __ret: [G; OUT_214] = [__v_34];
+                    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_24, __v_4, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } };
+                    let __v_32: G = __r_arr[0];
+                    let __ret: [G; OUT_214] = [__v_32];
                     record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
@@ -21504,7 +21570,7 @@ fn aiur_fn_215(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -21611,11 +21677,8 @@ fn aiur_fn_217(
     let __v_24: G = G::from_u64(0);
     let __v_25: G = G::from_u64(0);
     let __v_26: G = G::from_u64(0);
-    let __v_27: G = G::from_u64(1);
-    let __v_28: G = G::from_u64(1);
-    let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_217] = [__v_30];
+    let __v_27: G = { let __values: [G; 9] = [__v_6, __v_8, __v_10, __v_12, __v_22, __v_23, __v_24, __v_25, __v_26]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_217] = [__v_27];
     record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -21638,7 +21701,7 @@ fn aiur_fn_218(
     let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -21651,24 +21714,20 @@ fn aiur_fn_218(
         let __v_10: G = __r_arr[0];
         match __v_10.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_4]; 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_734] = { let __args: [G; IN_734] = [__v_4]; 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_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
                 let __v_12: G = G::from_u64(1);
-                let __v_13: G = G::from_u64(1);
-                let __v_14: G = G::from_u64(1);
-                let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_218] = [__v_12, __v_15];
+                let __v_13: G = G::from_u64(0);
+                let __ret: [G; OUT_218] = [__v_12, __v_13];
                 record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __v_13: G = G::from_u64(1);
-                let __v_14: G = G::from_u64(1);
-                let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_218] = [__v_12, __v_15];
+                let __v_13: G = G::from_u64(0);
+                let __ret: [G; OUT_218] = [__v_12, __v_13];
                 record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -21682,20 +21741,18 @@ fn aiur_fn_218(
             match __v_12.as_canonical_u64() {
               0u64 => {
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = G::from_u64(1);
-                let __v_15: G = G::from_u64(1);
-                let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_218] = [__v_13, __v_16];
+                let __v_14: G = G::from_u64(0);
+                let __ret: [G; OUT_218] = [__v_13, __v_14];
                 record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_4]; 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_734] = { let __args: [G; IN_734] = [__v_4]; 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_13: G = __r_arr[0];
                 match __v_13.as_canonical_u64() {
                   3u64 => {
                     let __v_14: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_14]; 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_727] = { let __args: [G; IN_727] = [__v_4, __v_14]; 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_15: G = __r_arr[0];
                     let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_15, __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_16: G = __r_arr[0];
@@ -21703,16 +21760,14 @@ fn aiur_fn_218(
                     match __v_16.as_canonical_u64() {
                       0u64 => {
                         let __v_18: G = G::from_u64(0);
-                        let __v_19: G = G::from_u64(1);
-                        let __v_20: G = G::from_u64(1);
-                        let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_218] = [__v_18, __v_21];
+                        let __v_19: G = G::from_u64(0);
+                        let __ret: [G; OUT_218] = [__v_18, __v_19];
                         record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       1u64 => {
                         let __v_18: G = G::from_u64(2);
-                        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_18]; 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_727] = { let __args: [G; IN_727] = [__v_4, __v_18]; 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_19: G = __r_arr[0];
                         let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_19, __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_20: G = __r_arr[0];
@@ -21744,10 +21799,8 @@ fn aiur_fn_218(
                   },
                   _ => {
                     let __v_14: G = G::from_u64(0);
-                    let __v_15: G = G::from_u64(1);
-                    let __v_16: G = G::from_u64(1);
-                    let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_218] = [__v_14, __v_17];
+                    let __v_15: G = G::from_u64(0);
+                    let __ret: [G; OUT_218] = [__v_14, __v_15];
                     record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
@@ -21759,10 +21812,8 @@ fn aiur_fn_218(
       },
       _ => {
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_218] = [__v_9, __v_12];
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_218] = [__v_9, __v_10];
         record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -21817,14 +21868,14 @@ fn aiur_fn_220(
 ) -> Result<[G; OUT_220], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -21844,7 +21895,7 @@ fn aiur_fn_220(
                 return Ok(__ret);
               },
               _ => {
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                 let __v_11: G = __loaded[0];
                 let __v_12: G = __loaded[1];
                 let __v_13: G = __loaded[2];
@@ -21911,86 +21962,81 @@ fn aiur_fn_221(
 ) -> Result<[G; OUT_221], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    match __v_1.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_11: G = __loaded[0];
-        let __v_12: G = __loaded[1];
-        let __v_13: G = __loaded[2];
-        let __v_14: G = __loaded[3];
-        let __v_15: G = __loaded[4];
-        let __v_16: G = __loaded[5];
-        let __v_17: G = __loaded[6];
-        let __v_18: G = __loaded[7];
-        let __v_19: G = __loaded[8];
-        let __v_20: G = __loaded[9];
-        match __v_11.as_canonical_u64() {
-          1u64 => {
-            let __v_21: G = (__v_8 + __v_9);
-            let __v_22: G = (__v_7 + __v_21);
-            let __v_23: G = (__v_6 + __v_22);
-            let __v_24: G = (__v_5 + __v_23);
-            let __v_25: G = G::from_bool((__v_24 == G::ZERO));
-            match __v_25.as_canonical_u64() {
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_221] = [__v_1, __v_2];
+        record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        match __v_9.as_canonical_u64() {
+          0u64 => {
+            let __v_10: G = (__v_7 + __v_8);
+            let __v_11: G = (__v_6 + __v_10);
+            let __v_12: G = (__v_5 + __v_11);
+            let __v_13: G = (__v_4 + __v_12);
+            let __v_14: G = G::from_bool((__v_13 == G::ZERO));
+            match __v_14.as_canonical_u64() {
               0u64 => {
-                let __v_26: G = G::from_u64(0);
-                let __v_27: G = G::from_u64(0);
-                let __ret: [G; OUT_221] = [__v_26, __v_27];
+                let __v_15: G = G::from_u64(0);
+                let __v_16: G = G::from_u64(0);
+                let __ret: [G; OUT_221] = [__v_15, __v_16];
                 record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_26: G = G::from_u64(256);
-                let __v_27: G = (__v_3 * __v_26);
-                let __v_28: G = G::from_u64(65536);
-                let __v_29: G = (__v_4 * __v_28);
-                let __v_30: G = (__v_27 + __v_29);
-                let __v_31: G = (__v_2 + __v_30);
-                let __v_32: G = G::from_u64(55296);
-                let __v_33: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_32.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                match __v_33.as_canonical_u64() {
+                let __v_15: G = G::from_u64(256);
+                let __v_16: G = (__v_2 * __v_15);
+                let __v_17: G = G::from_u64(65536);
+                let __v_18: G = (__v_3 * __v_17);
+                let __v_19: G = (__v_16 + __v_18);
+                let __v_20: G = (__v_1 + __v_19);
+                let __v_21: G = G::from_u64(55296);
+                let __v_22: G = { let __a_val = __v_20.as_canonical_u64(); let __b_val = __v_21.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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() {
                   1u64 => {
-                    let __v_34: G = G::from_u64(1);
-                    let __ret: [G; OUT_221] = [__v_34, __v_31];
+                    let __v_23: G = G::from_u64(1);
+                    let __ret: [G; OUT_221] = [__v_23, __v_20];
                     record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __v_34: G = G::from_u64(57343);
-                    let __v_35: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_31.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                    match __v_35.as_canonical_u64() {
+                    let __v_23: G = G::from_u64(57343);
+                    let __v_24: G = { let __a_val = __v_23.as_canonical_u64(); let __b_val = __v_20.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                    match __v_24.as_canonical_u64() {
                       0u64 => {
-                        let __v_36: G = G::from_u64(0);
-                        let __v_37: G = G::from_u64(0);
-                        let __ret: [G; OUT_221] = [__v_36, __v_37];
+                        let __v_25: G = G::from_u64(0);
+                        let __v_26: G = G::from_u64(0);
+                        let __ret: [G; OUT_221] = [__v_25, __v_26];
                         record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
-                        let __v_36: G = G::from_u64(1114112);
-                        let __v_37: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_36.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                        match __v_37.as_canonical_u64() {
+                        let __v_25: G = G::from_u64(1114112);
+                        let __v_26: G = { let __a_val = __v_20.as_canonical_u64(); let __b_val = __v_25.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                        match __v_26.as_canonical_u64() {
                           1u64 => {
-                            let __v_38: G = G::from_u64(1);
-                            let __ret: [G; OUT_221] = [__v_38, __v_31];
+                            let __v_27: G = G::from_u64(1);
+                            let __ret: [G; OUT_221] = [__v_27, __v_20];
                             record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
-                            let __v_38: G = G::from_u64(0);
-                            let __v_39: G = G::from_u64(0);
-                            let __ret: [G; OUT_221] = [__v_38, __v_39];
+                            let __v_27: G = G::from_u64(0);
+                            let __v_28: G = G::from_u64(0);
+                            let __ret: [G; OUT_221] = [__v_27, __v_28];
                             record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
@@ -22003,21 +22049,14 @@ fn aiur_fn_221(
             }
           },
           _ => {
-            let __v_21: G = G::from_u64(0);
-            let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_221] = [__v_21, __v_22];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(0);
+            let __ret: [G; OUT_221] = [__v_10, __v_11];
             record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_221] = [__v_11, __v_12];
-        record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
     }
   })
 }
@@ -22152,9 +22191,8 @@ fn aiur_fn_224(
     let __v_36: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_35.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
     match __v_36.as_canonical_u64() {
       1u64 => {
-        let __v_37: G = G::from_u64(0);
-        let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_224] = [__v_38];
+        let __v_37: G = { let __values: [G; 2] = [__v_0, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_224] = [__v_37];
         record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -22167,11 +22205,9 @@ fn aiur_fn_224(
             let __v_40: G = (__v_7 + __v_39);
             let __v_41: G = G::from_u64(192);
             let __v_42: G = (__v_9 + __v_41);
-            let __v_43: G = G::from_u64(0);
-            let __v_44: G = G::from_u64(0);
-            let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_224] = [__v_46];
+            let __v_43: G = { let __values: [G; 2] = [__v_40, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_44: G = { let __values: [G; 2] = [__v_42, __v_43]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_224] = [__v_44];
             record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -22186,13 +22222,10 @@ fn aiur_fn_224(
                 let __v_44: G = (__v_9 + __v_43);
                 let __v_45: G = G::from_u64(224);
                 let __v_46: G = (__v_11 + __v_45);
-                let __v_47: G = G::from_u64(0);
-                let __v_48: G = G::from_u64(0);
-                let __v_49: G = G::from_u64(0);
-                let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_224] = [__v_52];
+                let __v_47: G = { let __values: [G; 2] = [__v_42, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_48: G = { let __values: [G; 2] = [__v_44, __v_47]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_49: G = { let __values: [G; 2] = [__v_46, __v_48]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_224] = [__v_49];
                 record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -22205,15 +22238,11 @@ fn aiur_fn_224(
                 let __v_46: G = (__v_11 + __v_45);
                 let __v_47: G = G::from_u64(240);
                 let __v_48: G = (__v_13 + __v_47);
-                let __v_49: G = G::from_u64(0);
-                let __v_50: G = G::from_u64(0);
-                let __v_51: G = G::from_u64(0);
-                let __v_52: G = G::from_u64(0);
-                let __v_53: G = { let __values: [G; 3] = [__v_52, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_224] = [__v_56];
+                let __v_49: G = { let __values: [G; 2] = [__v_42, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_50: G = { let __values: [G; 2] = [__v_44, __v_49]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_51: G = { let __values: [G; 2] = [__v_46, __v_50]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_52: G = { let __values: [G; 2] = [__v_48, __v_51]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_224] = [__v_52];
                 record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -22478,7 +22507,7 @@ fn aiur_fn_226(
 ) -> Result<[G; OUT_226], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -22494,10 +22523,8 @@ fn aiur_fn_226(
           },
           _ => {
             let __v_5: G = G::from_u64(0);
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_226] = [__v_5, __v_8];
+            let __v_6: G = G::from_u64(0);
+            let __ret: [G; OUT_226] = [__v_5, __v_6];
             record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -22511,19 +22538,15 @@ fn aiur_fn_226(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_226] = [__v_7, __v_10];
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_226] = [__v_7, __v_8];
             record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_7: G = G::from_u64(0);
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_226] = [__v_7, __v_10];
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_226] = [__v_7, __v_8];
             record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -22539,10 +22562,8 @@ fn aiur_fn_226(
       },
       _ => {
         let __v_5: G = G::from_u64(0);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_226] = [__v_5, __v_8];
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_226] = [__v_5, __v_6];
         record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -22562,7 +22583,7 @@ fn aiur_fn_227(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -22589,10 +22610,8 @@ fn aiur_fn_227(
               },
               _ => {
                 let __v_10: G = G::from_u64(0);
-                let __v_11: G = G::from_u64(1);
-                let __v_12: G = G::from_u64(1);
-                let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_227] = [__v_10, __v_13];
+                let __v_11: G = G::from_u64(0);
+                let __ret: [G; OUT_227] = [__v_10, __v_11];
                 record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -22600,10 +22619,8 @@ fn aiur_fn_227(
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = G::from_u64(1);
-            let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_227] = [__v_8, __v_11];
+            let __v_9: G = G::from_u64(0);
+            let __ret: [G; OUT_227] = [__v_8, __v_9];
             record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -22611,10 +22628,8 @@ fn aiur_fn_227(
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_227] = [__v_6, __v_9];
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_227] = [__v_6, __v_7];
         record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -22636,7 +22651,7 @@ fn aiur_fn_228(
     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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_228] = [__v_4];
     record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -22655,29 +22670,25 @@ fn aiur_fn_229(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_229] = [__v_0];
         record.function_queries[229].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_229] = { let __args: [G; IN_229] = [__v_7, __v_4]; 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];
-        let __ret: [G; OUT_229] = [__v_8];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = G::from_u64(3);
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_2, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_3]; 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_7: G = __r_arr[0];
+        let __ret: [G; OUT_229] = [__v_7];
         record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -22947,7 +22958,7 @@ fn aiur_fn_230(
                                                             let __v_32: G = G::from_u64(0);
                                                             let __v_33: G = G::from_u64(0);
                                                             let __v_34: G = G::from_u64(0);
-                                                            let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                            let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                                             let __ret: [G; OUT_230] = [__v_31, __v_35];
                                                             record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                             return Ok(__ret);
@@ -22994,7 +23005,7 @@ fn aiur_fn_231(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -23008,27 +23019,25 @@ fn aiur_fn_231(
         match __v_7.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = G::from_u64(1);
-            let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_231] = [__v_8, __v_0, __v_11];
+            let __v_9: G = G::from_u64(0);
+            let __ret: [G; OUT_231] = [__v_8, __v_0, __v_9];
             record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_1]; 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_734] = { let __args: [G; IN_734] = [__v_1]; 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_8: G = __r_arr[0];
             let __v_9: G = G::from_u64(2);
             let __v_10: G = (__v_8 - __v_9);
             match __v_10.as_canonical_u64() {
               0u64 => {
                 let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_11]; 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_12: G = __r_arr[0];
                 let __v_13: G = G::from_u64(1);
-                let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_13]; 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_727] = { let __args: [G; IN_727] = [__v_1, __v_13]; 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_14: G = __r_arr[0];
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                 let __v_15: G = __loaded[0];
                 let __v_16: G = __loaded[1];
                 let __v_17: G = __loaded[2];
@@ -23044,10 +23053,8 @@ fn aiur_fn_231(
                       },
                       _ => {
                         let __v_19: G = G::from_u64(0);
-                        let __v_20: G = G::from_u64(1);
-                        let __v_21: G = G::from_u64(1);
-                        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_231] = [__v_19, __v_0, __v_22];
+                        let __v_20: G = G::from_u64(0);
+                        let __ret: [G; OUT_231] = [__v_19, __v_0, __v_20];
                         record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
@@ -23055,10 +23062,8 @@ fn aiur_fn_231(
                   },
                   _ => {
                     let __v_19: G = G::from_u64(0);
-                    let __v_20: G = G::from_u64(1);
-                    let __v_21: G = G::from_u64(1);
-                    let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_231] = [__v_19, __v_0, __v_22];
+                    let __v_20: G = G::from_u64(0);
+                    let __ret: [G; OUT_231] = [__v_19, __v_0, __v_20];
                     record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
@@ -23066,10 +23071,8 @@ fn aiur_fn_231(
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __v_12: G = G::from_u64(1);
-                let __v_13: G = G::from_u64(1);
-                let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_231] = [__v_11, __v_0, __v_14];
+                let __v_12: G = G::from_u64(0);
+                let __ret: [G; OUT_231] = [__v_11, __v_0, __v_12];
                 record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -23079,10 +23082,8 @@ fn aiur_fn_231(
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_231] = [__v_6, __v_0, __v_9];
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_231] = [__v_6, __v_0, __v_7];
         record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -23102,8 +23103,8 @@ fn aiur_fn_232(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = G::from_u64(0);
-    let __v_3: G = G::from_u64(1);
+    let __v_2: G = G::from_u64(1);
+    let __v_3: G = G::from_u64(0);
     let __v_4: G = G::from_u64(0);
     let __v_5: G = G::from_u64(0);
     let __v_6: G = G::from_u64(0);
@@ -23111,56 +23112,49 @@ fn aiur_fn_232(
     let __v_8: G = G::from_u64(0);
     let __v_9: G = G::from_u64(0);
     let __v_10: G = G::from_u64(0);
-    let __v_11: G = G::from_u64(1);
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_15]; 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_16: G = __r_arr[0];
-    let __v_17: G = G::from_u64(2);
+    let __v_11: G = { let __values: [G; 9] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __v_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_12]; 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_13: G = __r_arr[0];
+    let __v_14: G = G::from_u64(2);
     let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
-    let __v_18: G = __r_arr[0];
-    let __v_19: G = G::from_u64(1);
-    let __v_20: G = G::from_u64(1);
-    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_22: G = G::from_u64(0);
-    let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_16]; 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_24: G = __r_arr[0];
-    match __v_24.as_canonical_u64() {
+    let __v_15: G = __r_arr[0];
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = G::from_u64(0);
+    let __v_18: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_13]; 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_19: G = __r_arr[0];
+    match __v_19.as_canonical_u64() {
       1u64 => {
-        let __v_25: G = G::from_u64(3);
-        let __v_26: G = G::from_u64(0);
-        let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_232] = [__v_27];
+        let __v_20: G = G::from_u64(3);
+        let __v_21: G = G::from_u64(0);
+        let __v_22: G = { let __values: [G; 4] = [__v_20, __v_18, __v_0, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_232] = [__v_22];
         record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_25: G = G::from_u64(2);
+        let __v_20: G = G::from_u64(2);
         let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __v_27: G = G::from_u64(1);
-        let __v_28: G = G::from_u64(1);
-        let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_30: G = G::from_u64(0);
-        let __v_31: G = { let __values: [G; 4] = [__v_25, __v_26, __v_29, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_32: G = G::from_u64(7);
+        let __v_21: G = __r_arr[0];
+        let __v_22: G = G::from_u64(0);
+        let __v_23: G = G::from_u64(0);
+        let __v_24: G = { let __values: [G; 4] = [__v_20, __v_21, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_25: G = G::from_u64(7);
+        let __v_26: G = G::from_u64(0);
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_13, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_29: G = G::from_u64(3);
+        let __v_30: G = G::from_u64(3);
+        let __v_31: G = G::from_u64(0);
+        let __v_32: G = { let __values: [G; 4] = [__v_30, __v_24, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_33: G = G::from_u64(0);
-        let __v_34: G = G::from_u64(0);
-        let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_36: G = G::from_u64(3);
-        let __v_37: G = G::from_u64(3);
-        let __v_38: G = G::from_u64(0);
-        let __v_39: G = { let __values: [G; 4] = [__v_37, __v_31, __v_0, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_40: G = G::from_u64(0);
-        let __v_41: G = { let __values: [G; 4] = [__v_36, __v_39, __v_35, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_42: G = G::from_u64(3);
-        let __v_43: G = G::from_u64(0);
-        let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_232] = [__v_44];
+        let __v_34: G = { let __values: [G; 4] = [__v_29, __v_32, __v_28, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_35: G = G::from_u64(3);
+        let __v_36: G = G::from_u64(0);
+        let __v_37: G = { let __values: [G; 4] = [__v_35, __v_18, __v_34, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_232] = [__v_37];
         record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -23179,7 +23173,7 @@ fn aiur_fn_233(
 ) -> Result<[G; OUT_233], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -23194,7 +23188,7 @@ fn aiur_fn_233(
         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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -23272,23 +23266,21 @@ fn aiur_fn_234(
         let __v_4: G = G::from_u64(2);
         let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_4, __v_5, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_11: G = G::from_u64(3);
-        let __v_12: G = G::from_u64(3);
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = { let __values: [G; 4] = [__v_4, __v_5, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = G::from_u64(3);
+        let __v_10: G = G::from_u64(3);
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = { let __values: [G; 4] = [__v_10, __v_8, __v_0, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__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_15: G = __r_arr[0];
-        let __v_16: G = G::from_u64(0);
-        let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_18: G = G::from_u64(1);
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_17, __v_2]; 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_19: G = __r_arr[0];
-        let __ret: [G; OUT_234] = [__v_18, __v_19];
+        let __v_13: G = __r_arr[0];
+        let __v_14: G = G::from_u64(0);
+        let __v_15: G = { let __values: [G; 4] = [__v_9, __v_12, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_16: G = G::from_u64(1);
+        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_15, __v_2]; 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 __ret: [G; OUT_234] = [__v_16, __v_17];
         record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -23307,14 +23299,14 @@ fn aiur_fn_235(
 ) -> Result<[G; OUT_235], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       4u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -23324,7 +23316,7 @@ fn aiur_fn_235(
             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 __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_11: G = __loaded[0];
             let __v_12: G = __loaded[1];
             let __v_13: G = __loaded[2];
@@ -23343,16 +23335,16 @@ fn aiur_fn_235(
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_10]; 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_734] = { let __args: [G; IN_734] = [__v_10]; 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_17: G = __r_arr[0];
                     let __v_18: G = G::from_u64(1);
                     let __v_19: G = (__v_17 - __v_18);
                     match __v_19.as_canonical_u64() {
                       0u64 => {
                         let __v_20: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_20]; 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_727] = { let __args: [G; IN_727] = [__v_10, __v_20]; 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_21: G = __r_arr[0];
-                        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                         let __v_22: G = __loaded[0];
                         let __v_23: G = __loaded[1];
                         let __v_24: G = __loaded[2];
@@ -23431,13 +23423,13 @@ fn aiur_fn_236(
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_236] = [__v_7, __v_11];
         record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_4]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7]; 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_8: G = __r_arr[0];
@@ -23448,7 +23440,7 @@ fn aiur_fn_236(
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_236] = [__v_10, __v_14];
             record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -23457,7 +23449,7 @@ fn aiur_fn_236(
             let __v_10: G = (__v_1 + __v_2);
             let __v_11: G = G::from_u64(1);
             let __v_12: G = (__v_10 + __v_11);
-            let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_12]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_12]; 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_13: G = __r_arr[0];
             let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_13]; 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_14: G = __r_arr[0];
@@ -23467,17 +23459,17 @@ fn aiur_fn_236(
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
                 let __v_18: G = G::from_u64(0);
-                let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_236] = [__v_15, __v_19];
                 record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_10]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_10]; 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_15: G = __r_arr[0];
                 let __v_16: G = G::from_u64(1);
                 let __v_17: G = (__v_4 + __v_16);
-                let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_17]; 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_736] = { let __args: [G; IN_736] = [__v_0, __v_17]; 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_18: G = __r_arr[0];
                 let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_15]; 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_19: G = __r_arr[0];
@@ -23529,7 +23521,7 @@ fn aiur_fn_237(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_1]; 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_734] = { let __args: [G; IN_734] = [__v_1]; 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_3: G = __r_arr[0];
     let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
@@ -23549,14 +23541,14 @@ fn aiur_fn_237(
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_237] = [__v_10, __v_14];
             record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_10]; 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_727] = { let __args: [G; IN_727] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
@@ -23564,7 +23556,7 @@ fn aiur_fn_237(
             match __v_12.as_canonical_u64() {
               1u64 => {
                 let __v_14: G = G::from_u64(1);
-                let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_1, __v_14]; 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_736] = { let __args: [G; IN_736] = [__v_1, __v_14]; 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_15: G = __r_arr[0];
                 let __v_16: G = G::from_u64(1);
                 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)? } };
@@ -23582,7 +23574,7 @@ fn aiur_fn_237(
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_237] = [__v_14, __v_18];
                 record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -23602,14 +23594,14 @@ fn aiur_fn_237(
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_237] = [__v_10, __v_14];
                 record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_10]; 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_727] = { let __args: [G; IN_727] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
@@ -23617,7 +23609,7 @@ fn aiur_fn_237(
                 match __v_12.as_canonical_u64() {
                   1u64 => {
                     let __v_14: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_1, __v_14]; 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_736] = { let __args: [G; IN_736] = [__v_1, __v_14]; 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_15: G = __r_arr[0];
                     let __v_16: G = G::from_u64(1);
                     let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_13]; 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)? } };
@@ -23637,7 +23629,7 @@ fn aiur_fn_237(
                     let __v_15: G = G::from_u64(0);
                     let __v_16: G = G::from_u64(0);
                     let __v_17: G = G::from_u64(0);
-                    let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                     let __ret: [G; OUT_237] = [__v_14, __v_18];
                     record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -23681,17 +23673,17 @@ fn aiur_fn_238(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_238] = [__v_5, __v_9];
         record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_5]; 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_727] = { let __args: [G; IN_727] = [__v_1, __v_5]; 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_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(1);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_7]; 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_727] = { let __args: [G; IN_727] = [__v_1, __v_7]; 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_8: G = __r_arr[0];
         let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__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 __v_9: G = __r_arr[0];
@@ -23709,7 +23701,7 @@ fn aiur_fn_238(
                 match __v_13.as_canonical_u64() {
                   1u64 => {
                     let __v_15: G = G::from_u64(2);
-                    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_1, __v_15]; 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_736] = { let __args: [G; IN_736] = [__v_1, __v_15]; 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_16: G = __r_arr[0];
                     let __v_17: G = G::from_u64(1);
                     let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_14, __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)? } };
@@ -23723,7 +23715,7 @@ fn aiur_fn_238(
                     let __v_16: G = G::from_u64(0);
                     let __v_17: G = G::from_u64(0);
                     let __v_18: G = G::from_u64(0);
-                    let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                     let __ret: [G; OUT_238] = [__v_15, __v_19];
                     record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -23735,7 +23727,7 @@ fn aiur_fn_238(
                 let __v_14: G = G::from_u64(0);
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
-                let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_238] = [__v_13, __v_17];
                 record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -23760,7 +23752,7 @@ fn aiur_fn_238(
                 let __v_14: G = G::from_u64(0);
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
-                let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_238] = [__v_13, __v_17];
                 record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -23821,14 +23813,14 @@ fn aiur_fn_239(
         let __v_23: G = G::from_u64(0);
         let __v_24: G = G::from_u64(0);
         let __v_25: G = G::from_u64(0);
-        let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_239] = [__v_22, __v_26];
         record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_22: G = G::from_u64(2);
-        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_3, __v_22]; 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_736] = { let __args: [G; IN_736] = [__v_3, __v_22]; 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_23: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
@@ -23847,7 +23839,7 @@ fn aiur_fn_239(
                 let __v_27: G = G::from_u64(0);
                 let __v_28: G = G::from_u64(0);
                 let __v_29: G = G::from_u64(0);
-                let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_239] = [__v_26, __v_30];
                 record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -23883,22 +23875,20 @@ fn aiur_fn_240(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = G::from_u64(2);
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = G::from_u64(1);
-    let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_8: G = G::from_u64(0);
-    let __v_9: G = { let __values: [G; 4] = [__v_4, __v_0, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_10: G = G::from_u64(3);
-    let __v_11: G = G::from_u64(3);
-    let __v_12: G = G::from_u64(0);
-    let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_5: G = G::from_u64(0);
+    let __v_6: G = G::from_u64(0);
+    let __v_7: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_8: G = G::from_u64(3);
+    let __v_9: G = G::from_u64(3);
+    let __v_10: G = G::from_u64(0);
+    let __v_11: G = { let __values: [G; 4] = [__v_9, __v_7, __v_1, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     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 __v_14: G = __r_arr[0];
-    let __v_15: G = G::from_u64(0);
-    let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_3]; 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 __ret: [G; OUT_240] = [__v_17];
+    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_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_14, __v_3]; 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_240] = [__v_15];
     record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -23931,143 +23921,139 @@ fn aiur_fn_241(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_10: G = __loaded[0];
-        let __v_11: G = __loaded[1];
-        let __v_12: G = __loaded[2];
-        match __v_10.as_canonical_u64() {
-          1u64 => {
+        match __v_0.as_canonical_u64() {
+          0u64 => {
             let __ret: [G; OUT_241] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
             record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_10: G = __loaded[0];
+            let __v_11: G = __loaded[1];
             match __v_9.as_canonical_u64() {
               0u64 => {
-                let __v_13: G = G::from_u64(1);
-                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__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[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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                let __v_12: G = G::from_u64(1);
+                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_11, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12]; 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_13: G = __r_arr[0];
+                let __v_14: G = __r_arr[1];
+                let __v_15: G = __r_arr[2];
+                let __v_16: G = __r_arr[3];
+                let __v_17: G = __r_arr[4];
+                let __v_18: G = __r_arr[5];
+                let __v_19: G = __r_arr[6];
+                let __v_20: G = __r_arr[7];
+                let __ret: [G; OUT_241] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
                 record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __v_13: G = G::from_u64(2);
-                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__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[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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                let __v_12: G = G::from_u64(2);
+                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_11, __v_1, __v_10, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12]; 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_13: G = __r_arr[0];
+                let __v_14: G = __r_arr[1];
+                let __v_15: G = __r_arr[2];
+                let __v_16: G = __r_arr[3];
+                let __v_17: G = __r_arr[4];
+                let __v_18: G = __r_arr[5];
+                let __v_19: G = __r_arr[6];
+                let __v_20: G = __r_arr[7];
+                let __ret: [G; OUT_241] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
                 record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               2u64 => {
-                let __v_13: G = G::from_u64(3);
-                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__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[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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                let __v_12: G = G::from_u64(3);
+                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_11, __v_1, __v_2, __v_10, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12]; 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_13: G = __r_arr[0];
+                let __v_14: G = __r_arr[1];
+                let __v_15: G = __r_arr[2];
+                let __v_16: G = __r_arr[3];
+                let __v_17: G = __r_arr[4];
+                let __v_18: G = __r_arr[5];
+                let __v_19: G = __r_arr[6];
+                let __v_20: G = __r_arr[7];
+                let __ret: [G; OUT_241] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
                 record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               3u64 => {
-                let __v_13: G = G::from_u64(4);
-                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__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[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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                let __v_12: G = G::from_u64(4);
+                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_11, __v_1, __v_2, __v_3, __v_10, __v_5, __v_6, __v_7, __v_8, __v_12]; 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_13: G = __r_arr[0];
+                let __v_14: G = __r_arr[1];
+                let __v_15: G = __r_arr[2];
+                let __v_16: G = __r_arr[3];
+                let __v_17: G = __r_arr[4];
+                let __v_18: G = __r_arr[5];
+                let __v_19: G = __r_arr[6];
+                let __v_20: G = __r_arr[7];
+                let __ret: [G; OUT_241] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
                 record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               4u64 => {
-                let __v_13: G = G::from_u64(5);
-                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__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[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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                let __v_12: G = G::from_u64(5);
+                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_10, __v_6, __v_7, __v_8, __v_12]; 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_13: G = __r_arr[0];
+                let __v_14: G = __r_arr[1];
+                let __v_15: G = __r_arr[2];
+                let __v_16: G = __r_arr[3];
+                let __v_17: G = __r_arr[4];
+                let __v_18: G = __r_arr[5];
+                let __v_19: G = __r_arr[6];
+                let __v_20: G = __r_arr[7];
+                let __ret: [G; OUT_241] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
                 record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               5u64 => {
-                let __v_13: G = G::from_u64(6);
-                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__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[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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                let __v_12: G = G::from_u64(6);
+                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_10, __v_7, __v_8, __v_12]; 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_13: G = __r_arr[0];
+                let __v_14: G = __r_arr[1];
+                let __v_15: G = __r_arr[2];
+                let __v_16: G = __r_arr[3];
+                let __v_17: G = __r_arr[4];
+                let __v_18: G = __r_arr[5];
+                let __v_19: G = __r_arr[6];
+                let __v_20: G = __r_arr[7];
+                let __ret: [G; OUT_241] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
                 record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               6u64 => {
-                let __v_13: G = G::from_u64(7);
-                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__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[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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                let __v_12: G = G::from_u64(7);
+                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_10, __v_8, __v_12]; 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_13: G = __r_arr[0];
+                let __v_14: G = __r_arr[1];
+                let __v_15: G = __r_arr[2];
+                let __v_16: G = __r_arr[3];
+                let __v_17: G = __r_arr[4];
+                let __v_18: G = __r_arr[5];
+                let __v_19: G = __r_arr[6];
+                let __v_20: G = __r_arr[7];
+                let __ret: [G; OUT_241] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
                 record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_13: G = G::from_u64(8);
-                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__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[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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_241] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                let __v_12: G = G::from_u64(8);
+                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_12]; 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_13: G = __r_arr[0];
+                let __v_14: G = __r_arr[1];
+                let __v_15: G = __r_arr[2];
+                let __v_16: G = __r_arr[3];
+                let __v_17: G = __r_arr[4];
+                let __v_18: G = __r_arr[5];
+                let __v_19: G = __r_arr[6];
+                let __v_20: G = __r_arr[7];
+                let __ret: [G; OUT_241] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
                 record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-          },
         }
       },
     }
@@ -24093,30 +24079,24 @@ fn aiur_fn_242(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_2: G = __loaded[0];
-        let __v_3: G = __loaded[1];
-        let __v_4: G = __loaded[2];
-        match __v_2.as_canonical_u64() {
-          1u64 => {
-            let __v_5: G = G::from_u64(1);
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_242] = [__v_7];
-            record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+        match __v_0.as_canonical_u64() {
           0u64 => {
-            let __v_5: G = G::from_u64(1);
-            let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4, __v_6]; 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_242] = [__v_7];
+            let __v_2: G = G::from_u64(0);
+            let __ret: [G; OUT_242] = [__v_2];
             record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_2: G = __loaded[0];
+            let __v_3: G = __loaded[1];
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = (__v_1 - __v_4);
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_3, __v_5]; 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 __ret: [G; OUT_242] = [__v_6];
+            record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
@@ -24156,68 +24136,45 @@ fn aiur_fn_243(
     let __v_18: G = G::from_u64(8);
     let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_20: G = __loaded[0];
-    let __v_21: G = __loaded[1];
-    let __v_22: G = __loaded[2];
-    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_20.as_canonical_u64() {
-  1u64 => {
-    let __v_23: G = G::from_u64(1);
-    let __v_24: G = G::from_u64(1);
-    let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    break '__mc_0 [__v_25];
+    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_19.as_canonical_u64() {
+  0u64 => {
+    let __v_20: G = G::from_u64(0);
+    break '__mc_0 [__v_20];
   },
   _ => {
     let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_19]; 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_23: G = __r_arr[0];
-    break '__mc_0 [__v_23];
+    let __v_20: G = __r_arr[0];
+    break '__mc_0 [__v_20];
   },
 }
  };
-    let __v_23: G = __mc_out___mc_0[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_24: G = __loaded[0];
-    let __v_25: G = __loaded[1];
-    let __v_26: G = __loaded[2];
-    let __v_27: G = __loaded[3];
-    let __v_28: G = __loaded[4];
-    let __v_29: G = __loaded[5];
-    let __v_30: G = __loaded[6];
-    let __v_31: G = __loaded[7];
-    let __v_32: G = __loaded[8];
-    let __v_33: G = __loaded[9];
-    match __v_24.as_canonical_u64() {
-      1u64 => {
+    let __v_20: G = __mc_out___mc_0[0];
+    match __v_20.as_canonical_u64() {
+      0u64 => {
         let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
-        let __v_34: G = __r_arr[0];
-        match __v_34.as_canonical_u64() {
+        let __v_21: G = __r_arr[0];
+        match __v_21.as_canonical_u64() {
           1u64 => {
-            let __v_35: G = G::from_u64(1);
-            let __v_36: G = G::from_u64(1);
-            let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_243] = [__v_37];
+            let __v_22: G = G::from_u64(0);
+            let __ret: [G; OUT_243] = [__v_22];
             record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __v_35: G = G::from_u64(0);
-            let __v_36: G = G::from_u64(1);
-            let __v_37: G = G::from_u64(1);
-            let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_243] = [__v_39];
+            let __v_22: G = G::from_u64(0);
+            let __v_23: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_22]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_243] = [__v_23];
             record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
           },
         }
       },
       _ => {
-        let __v_34: G = G::from_u64(0);
-        let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_243] = [__v_35];
+        let __v_21: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_243] = [__v_21];
         record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -24236,7 +24193,7 @@ fn aiur_fn_244(
 ) -> Result<[G; OUT_244], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -24250,7 +24207,7 @@ fn aiur_fn_244(
       0u64 => {
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_244] = [__v_12];
         record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24260,7 +24217,7 @@ fn aiur_fn_244(
         let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2]; 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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_244] = [__v_13];
         record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24271,7 +24228,7 @@ fn aiur_fn_244(
         let __v_11: G = __r_arr[0];
         let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; 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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_244] = [__v_13];
         record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24282,7 +24239,7 @@ fn aiur_fn_244(
         let __v_11: G = __r_arr[0];
         let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; 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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_244] = [__v_13];
         record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24292,7 +24249,7 @@ fn aiur_fn_244(
         let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_244] = [__v_13];
         record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24316,44 +24273,37 @@ fn aiur_fn_245(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 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_245] = [__v_14];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_245] = [__v_2];
         record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+      _ => {
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_11]; 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_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_12]; 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_244] = { let __args: [G; IN_244] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_13]; 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_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11, __v_1]; 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_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_245] = [__v_17];
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __v_15: G = { let __values: [G; 2] = [__v_13, __v_14]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_245] = [__v_15];
         record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -24373,7 +24323,7 @@ fn aiur_fn_246(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -24396,13 +24346,13 @@ fn aiur_fn_246(
       0u64 => {
         let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_23]; 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_727] = { let __args: [G; IN_727] = [__v_4, __v_23]; 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_24: G = __r_arr[0];
         let __v_25: G = G::from_u64(1);
         let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_24]; 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_26: G = __r_arr[0];
         let __v_27: G = G::from_u64(0);
-        let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_246] = [__v_28];
         record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24412,7 +24362,7 @@ fn aiur_fn_246(
         let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
         let __v_25: G = G::from_u64(0);
-        let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_246] = [__v_26];
         record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24420,13 +24370,13 @@ fn aiur_fn_246(
       2u64 => {
         let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_23]; 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_727] = { let __args: [G; IN_727] = [__v_2, __v_23]; 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_24: G = __r_arr[0];
         let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(2);
         let __v_27: G = G::from_u64(0);
-        let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_246] = [__v_28];
         record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24434,13 +24384,13 @@ fn aiur_fn_246(
       3u64 => {
         let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_23]; 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_727] = { let __args: [G; IN_727] = [__v_3, __v_23]; 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_24: G = __r_arr[0];
         let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(2);
         let __v_27: G = G::from_u64(0);
-        let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_246] = [__v_28];
         record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24448,14 +24398,14 @@ fn aiur_fn_246(
       4u64 => {
         let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_23]; 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_727] = { let __args: [G; IN_727] = [__v_2, __v_23]; 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_24: G = __r_arr[0];
         let __v_25: G = G::from_u64(8);
         let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
-        let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_246] = [__v_28];
         record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24463,7 +24413,7 @@ fn aiur_fn_246(
       5u64 => {
         let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_23]; 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_727] = { let __args: [G; IN_727] = [__v_2, __v_23]; 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_24: G = __r_arr[0];
         let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_24]; 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_25: G = __r_arr[0];
@@ -24471,7 +24421,7 @@ fn aiur_fn_246(
         let __v_26: G = G::from_u64(7);
         let __v_27: G = G::from_u64(1);
         let __v_28: G = G::from_u64(0);
-        let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_246] = [__v_29];
         record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24479,7 +24429,7 @@ fn aiur_fn_246(
       6u64 => {
         let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_23]; 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_727] = { let __args: [G; IN_727] = [__v_2, __v_23]; 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_24: G = __r_arr[0];
         let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_24]; 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_25: G = __r_arr[0];
@@ -24488,7 +24438,7 @@ fn aiur_fn_246(
         let __v_27: G = G::from_u64(7);
         let __v_28: G = G::from_u64(0);
         let __v_29: G = G::from_u64(0);
-        let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_246] = [__v_30];
         record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24500,7 +24450,7 @@ fn aiur_fn_246(
         let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(0);
-        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_246] = [__v_27];
         record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24512,7 +24462,7 @@ fn aiur_fn_246(
         let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(0);
-        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_246] = [__v_27];
         record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24524,7 +24474,7 @@ fn aiur_fn_246(
         let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(0);
-        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_246] = [__v_27];
         record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24537,7 +24487,7 @@ fn aiur_fn_246(
         let __v_25: G = __r_arr[0];
         let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_16, __v_1, __v_2, __v_3, __v_4]; 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_26: G = __r_arr[0];
-        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_246] = [__v_27];
         record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -24545,22 +24495,28 @@ fn aiur_fn_246(
       11u64 => {
         let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_1, __v_23]; 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_736] = { let __args: [G; IN_736] = [__v_1, __v_23]; 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_24: G = __r_arr[0];
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_25: G = __loaded[0];
-        let __v_26: G = __loaded[1];
-        let __v_27: G = __loaded[2];
-        match __v_25.as_canonical_u64() {
+        match __v_24.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_26, __v_1, __v_2, __v_3, __v_4]; 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_28: G = __r_arr[0];
-            let __ret: [G; OUT_246] = [__v_28];
+            let __v_25: G = G::from_u64(0);
+            let __v_26: G = G::from_u64(1);
+            if (__v_25 != __v_26) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_246] = [__v_25];
             record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_25: G = __loaded[0];
+            let __v_26: G = __loaded[1];
+            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+            let __v_27: G = __r_arr[0];
+            let __ret: [G; OUT_246] = [__v_27];
+            record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
@@ -24740,61 +24696,57 @@ fn aiur_fn_250(
 ) -> Result<[G; OUT_250], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    let __v_11: G = __loaded[10];
-    let __v_12: G = __loaded[11];
-    let __v_13: G = __loaded[12];
-    let __v_14: G = __loaded[13];
-    let __v_15: G = __loaded[14];
-    let __v_16: G = __loaded[15];
-    let __v_17: G = __loaded[16];
-    let __v_18: G = __loaded[17];
-    let __v_19: G = __loaded[18];
-    let __v_20: G = __loaded[19];
-    let __v_21: G = __loaded[20];
-    let __v_22: G = __loaded[21];
-    let __v_23: G = __loaded[22];
-    let __v_24: G = __loaded[23];
-    let __v_25: G = __loaded[24];
-    let __v_26: G = __loaded[25];
-    let __v_27: G = __loaded[26];
-    let __v_28: G = __loaded[27];
-    let __v_29: G = __loaded[28];
-    let __v_30: G = __loaded[29];
-    let __v_31: G = __loaded[30];
-    let __v_32: G = __loaded[31];
-    let __v_33: G = __loaded[32];
-    let __v_34: G = __loaded[33];
-    let __v_35: G = __loaded[34];
-    let __v_36: G = __loaded[35];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_37: G = G::from_u64(0);
-        let __ret: [G; OUT_250] = [__v_37];
-        record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_36]; 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_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_250] = [__v_39];
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_250] = [__v_1];
         record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 35] = { let __mq = record.memory_queries.get_mut(&35).ok_or(ExecError::InvalidMemorySize(35))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 35 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 35] = __args[..35].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __v_10: G = __loaded[9];
+        let __v_11: G = __loaded[10];
+        let __v_12: G = __loaded[11];
+        let __v_13: G = __loaded[12];
+        let __v_14: G = __loaded[13];
+        let __v_15: G = __loaded[14];
+        let __v_16: G = __loaded[15];
+        let __v_17: G = __loaded[16];
+        let __v_18: G = __loaded[17];
+        let __v_19: G = __loaded[18];
+        let __v_20: G = __loaded[19];
+        let __v_21: G = __loaded[20];
+        let __v_22: G = __loaded[21];
+        let __v_23: G = __loaded[22];
+        let __v_24: G = __loaded[23];
+        let __v_25: G = __loaded[24];
+        let __v_26: G = __loaded[25];
+        let __v_27: G = __loaded[26];
+        let __v_28: G = __loaded[27];
+        let __v_29: G = __loaded[28];
+        let __v_30: G = __loaded[29];
+        let __v_31: G = __loaded[30];
+        let __v_32: G = __loaded[31];
+        let __v_33: G = __loaded[32];
+        let __v_34: G = __loaded[33];
+        let __v_35: G = __loaded[34];
+        let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_35]; 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_36: G = __r_arr[0];
+        let __v_37: G = G::from_u64(1);
+        let __v_38: G = (__v_36 + __v_37);
+        let __ret: [G; OUT_250] = [__v_38];
+        record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -24812,98 +24764,104 @@ fn aiur_fn_251(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: G = __loaded[31];
-    let __v_34: G = __loaded[32];
-    let __v_35: G = __loaded[33];
-    let __v_36: G = __loaded[34];
-    let __v_37: G = __loaded[35];
-    match __v_2.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(1);
+        if (__v_2 != __v_3) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_251] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2];
+        record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 35] = { let __mq = record.memory_queries.get_mut(&35).ok_or(ExecError::InvalidMemorySize(35))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 35 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 35] = __args[..35].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __v_11: G = __loaded[9];
+        let __v_12: G = __loaded[10];
+        let __v_13: G = __loaded[11];
+        let __v_14: G = __loaded[12];
+        let __v_15: G = __loaded[13];
+        let __v_16: G = __loaded[14];
+        let __v_17: G = __loaded[15];
+        let __v_18: G = __loaded[16];
+        let __v_19: G = __loaded[17];
+        let __v_20: G = __loaded[18];
+        let __v_21: G = __loaded[19];
+        let __v_22: G = __loaded[20];
+        let __v_23: G = __loaded[21];
+        let __v_24: G = __loaded[22];
+        let __v_25: G = __loaded[23];
+        let __v_26: G = __loaded[24];
+        let __v_27: G = __loaded[25];
+        let __v_28: G = __loaded[26];
+        let __v_29: G = __loaded[27];
+        let __v_30: G = __loaded[28];
+        let __v_31: G = __loaded[29];
+        let __v_32: G = __loaded[30];
+        let __v_33: G = __loaded[31];
+        let __v_34: G = __loaded[32];
+        let __v_35: G = __loaded[33];
+        let __v_36: G = __loaded[34];
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_251] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+            let __ret: [G; OUT_251] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35];
             record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_38: G = G::from_u64(1);
-            let __v_39: G = (__v_1 - __v_38);
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_37, __v_39]; 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_40: G = __r_arr[0];
-            let __v_41: G = __r_arr[1];
-            let __v_42: G = __r_arr[2];
-            let __v_43: G = __r_arr[3];
-            let __v_44: G = __r_arr[4];
-            let __v_45: G = __r_arr[5];
-            let __v_46: G = __r_arr[6];
-            let __v_47: G = __r_arr[7];
-            let __v_48: G = __r_arr[8];
-            let __v_49: G = __r_arr[9];
-            let __v_50: G = __r_arr[10];
-            let __v_51: G = __r_arr[11];
-            let __v_52: G = __r_arr[12];
-            let __v_53: G = __r_arr[13];
-            let __v_54: G = __r_arr[14];
-            let __v_55: G = __r_arr[15];
-            let __v_56: G = __r_arr[16];
-            let __v_57: G = __r_arr[17];
-            let __v_58: G = __r_arr[18];
-            let __v_59: G = __r_arr[19];
-            let __v_60: G = __r_arr[20];
-            let __v_61: G = __r_arr[21];
-            let __v_62: G = __r_arr[22];
-            let __v_63: G = __r_arr[23];
-            let __v_64: G = __r_arr[24];
-            let __v_65: G = __r_arr[25];
-            let __v_66: G = __r_arr[26];
-            let __v_67: G = __r_arr[27];
-            let __v_68: G = __r_arr[28];
-            let __v_69: G = __r_arr[29];
-            let __v_70: G = __r_arr[30];
-            let __v_71: G = __r_arr[31];
-            let __v_72: G = __r_arr[32];
-            let __v_73: G = __r_arr[33];
-            let __ret: [G; OUT_251] = [__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];
+            let __v_37: G = G::from_u64(1);
+            let __v_38: G = (__v_1 - __v_37);
+            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_36, __v_38]; 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_39: G = __r_arr[0];
+            let __v_40: G = __r_arr[1];
+            let __v_41: G = __r_arr[2];
+            let __v_42: G = __r_arr[3];
+            let __v_43: G = __r_arr[4];
+            let __v_44: G = __r_arr[5];
+            let __v_45: G = __r_arr[6];
+            let __v_46: G = __r_arr[7];
+            let __v_47: G = __r_arr[8];
+            let __v_48: G = __r_arr[9];
+            let __v_49: G = __r_arr[10];
+            let __v_50: G = __r_arr[11];
+            let __v_51: G = __r_arr[12];
+            let __v_52: G = __r_arr[13];
+            let __v_53: G = __r_arr[14];
+            let __v_54: G = __r_arr[15];
+            let __v_55: G = __r_arr[16];
+            let __v_56: G = __r_arr[17];
+            let __v_57: G = __r_arr[18];
+            let __v_58: G = __r_arr[19];
+            let __v_59: G = __r_arr[20];
+            let __v_60: G = __r_arr[21];
+            let __v_61: G = __r_arr[22];
+            let __v_62: G = __r_arr[23];
+            let __v_63: G = __r_arr[24];
+            let __v_64: G = __r_arr[25];
+            let __v_65: G = __r_arr[26];
+            let __v_66: G = __r_arr[27];
+            let __v_67: G = __r_arr[28];
+            let __v_68: G = __r_arr[29];
+            let __v_69: G = __r_arr[30];
+            let __v_70: G = __r_arr[31];
+            let __v_71: G = __r_arr[32];
+            let __v_72: G = __r_arr[33];
+            let __ret: [G; OUT_251] = [__v_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];
             record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -25061,49 +25019,42 @@ fn aiur_fn_254(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-    let __v_6: G = __loaded[0];
-    let __v_7: G = __loaded[1];
-    let __v_8: G = __loaded[2];
-    let __v_9: G = __loaded[3];
-    let __v_10: G = __loaded[4];
-    let __v_11: G = __loaded[5];
-    let __v_12: G = __loaded[6];
-    let __v_13: G = __loaded[7];
-    let __v_14: G = __loaded[8];
-    let __v_15: G = __loaded[9];
-    let __v_16: G = __loaded[10];
-    match __v_6.as_canonical_u64() {
-      1u64 => {
-        let __v_17: G = G::from_u64(1);
-        let __v_18: G = G::from_u64(1);
-        let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_254] = [__v_19];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_254] = [__v_6];
         record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_7.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        let __v_9: G = __loaded[3];
+        let __v_10: G = __loaded[4];
+        let __v_11: G = __loaded[5];
+        let __v_12: G = __loaded[6];
+        let __v_13: G = __loaded[7];
+        let __v_14: G = __loaded[8];
+        let __v_15: G = __loaded[9];
+        match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_15, __v_1, __v_2, __v_3, __v_4]; 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_246] = { let __args: [G; IN_246] = [__v_14, __v_1, __v_2, __v_3, __v_4]; 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_16: G = __r_arr[0];
+            let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __v_18: G = G::from_u64(0);
-            let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __v_20: G = G::from_u64(1);
-            let __v_21: G = (__v_5 + __v_20);
-            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; 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_22: G = __r_arr[0];
-            let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_254] = [__v_23];
+            let __v_18: G = G::from_u64(1);
+            let __v_19: G = (__v_5 + __v_18);
+            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_19]; 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_20: G = __r_arr[0];
+            let __v_21: G = { let __values: [G; 4] = [__v_5, __v_17, __v_16, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_254] = [__v_21];
             record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-      },
     }
   })
 }
@@ -25205,7 +25156,7 @@ fn aiur_fn_256(
 ) -> Result<[G; OUT_256], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -25296,20 +25247,9 @@ fn aiur_fn_256(
     let __v_84: G = __r_arr[46];
     let __v_85: G = __r_arr[47];
     let __v_86: G = __r_arr[48];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_87: G = __loaded[0];
-    let __v_88: G = __loaded[1];
-    let __v_89: G = __loaded[2];
-    let __v_90: G = G::from_u64(1);
-    let __v_91: G = G::from_u64(1);
-    if (__v_87 != __v_90) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_90.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) });
-    }
-    if (__v_88 != __v_91) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_91.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) });
-    }
-    if (__v_89 != __v_91) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_91.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) });
+    let __v_87: G = G::from_u64(0);
+    if (__v_86 != __v_87) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_87.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) });
     }
     let __ret: [G; OUT_256] = [__v_38, __v_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[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -25328,7 +25268,7 @@ fn aiur_fn_257(
 ) -> Result<[G; OUT_257], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -25368,18 +25308,24 @@ fn aiur_fn_257(
     let __v_36: G = G::from_u64(3);
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_37: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_38: G = __loaded[0];
-    let __v_39: G = __loaded[1];
-    let __v_40: G = __loaded[2];
-    match __v_38.as_canonical_u64() {
+    match __v_37.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_257] = [__v_39];
+        let __v_38: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_257] = [__v_38];
         record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_38.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_38: G = __loaded[0];
+        let __v_39: G = __loaded[1];
+        let __ret: [G; OUT_257] = [__v_38];
+        record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -25396,7 +25342,7 @@ fn aiur_fn_258(
 ) -> Result<[G; OUT_258], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -25531,10 +25477,8 @@ fn aiur_fn_260(
         let __v_14: G = __r_arr[0];
         match __v_14.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 __ret: [G; OUT_260] = [__v_17];
+            let __v_15: G = G::from_u64(0);
+            let __ret: [G; OUT_260] = [__v_15];
             record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -25623,18 +25567,13 @@ fn aiur_fn_261(
     let __v_50: G = __r_arr[0];
     match __v_50.as_canonical_u64() {
       0u64 => {
-        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 } };
-        break '__mc_0 [__v_53];
+        let __v_51: G = G::from_u64(0);
+        break '__mc_0 [__v_51];
       },
       _ => {
         let __v_51: G = G::from_u64(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 __v_55: G = { let __values: [G; 3] = [__v_51, __v_0, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        break '__mc_0 [__v_55];
+        let __v_52: G = { let __values: [G; 2] = [__v_0, __v_51]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        break '__mc_0 [__v_52];
       },
     }
   },
@@ -25654,52 +25593,48 @@ fn aiur_fn_261(
             let __v_60: G = __r_arr[9];
             let __v_61: G = __r_arr[10];
             let __v_62: G = __r_arr[11];
-            let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_261] = [__v_63];
             record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
-            let __v_49: G = G::from_u64(1);
-            let __v_50: G = G::from_u64(1);
-            let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } };
-            let __v_52: G = __r_arr[0];
-            let __v_53: G = __r_arr[1];
-            let __v_54: G = __r_arr[2];
-            let __v_55: G = __r_arr[3];
-            let __v_56: G = __r_arr[4];
-            let __v_57: G = __r_arr[5];
-            let __v_58: G = __r_arr[6];
-            let __v_59: G = __r_arr[7];
-            let __v_60: G = __r_arr[8];
-            let __v_61: G = __r_arr[9];
-            let __v_62: G = __r_arr[10];
-            let __v_63: G = __r_arr[11];
-            let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_261] = [__v_64];
+            let __v_49: G = G::from_u64(0);
+            let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_49, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } };
+            let __v_50: G = __r_arr[0];
+            let __v_51: G = __r_arr[1];
+            let __v_52: G = __r_arr[2];
+            let __v_53: G = __r_arr[3];
+            let __v_54: G = __r_arr[4];
+            let __v_55: G = __r_arr[5];
+            let __v_56: G = __r_arr[6];
+            let __v_57: G = __r_arr[7];
+            let __v_58: G = __r_arr[8];
+            let __v_59: G = __r_arr[9];
+            let __v_60: G = __r_arr[10];
+            let __v_61: G = __r_arr[11];
+            let __v_62: G = { let __values: [G; 12] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_261] = [__v_62];
             record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
-            let __v_49: G = G::from_u64(1);
-            let __v_50: G = G::from_u64(1);
-            let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_52: G = __r_arr[0];
-            let __v_53: G = __r_arr[1];
-            let __v_54: G = __r_arr[2];
-            let __v_55: G = __r_arr[3];
-            let __v_56: G = __r_arr[4];
-            let __v_57: G = __r_arr[5];
-            let __v_58: G = __r_arr[6];
-            let __v_59: G = __r_arr[7];
-            let __v_60: G = __r_arr[8];
-            let __v_61: G = __r_arr[9];
-            let __v_62: G = __r_arr[10];
-            let __v_63: G = __r_arr[11];
-            let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_261] = [__v_64];
+            let __v_49: G = G::from_u64(0);
+            let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_49, __v_48]; 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_50: G = __r_arr[0];
+            let __v_51: G = __r_arr[1];
+            let __v_52: G = __r_arr[2];
+            let __v_53: G = __r_arr[3];
+            let __v_54: G = __r_arr[4];
+            let __v_55: G = __r_arr[5];
+            let __v_56: G = __r_arr[6];
+            let __v_57: G = __r_arr[7];
+            let __v_58: G = __r_arr[8];
+            let __v_59: G = __r_arr[9];
+            let __v_60: G = __r_arr[10];
+            let __v_61: G = __r_arr[11];
+            let __v_62: G = { let __values: [G; 12] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_261] = [__v_62];
             record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -25757,26 +25692,23 @@ fn aiur_fn_261(
           },
           1u64 => {
             let __v_49: G = G::from_u64(0);
-            let __v_50: G = G::from_u64(1);
-            let __v_51: G = G::from_u64(1);
-            let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_54: G = G::from_u64(0);
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
-            let __v_55: G = __r_arr[0];
-            let __v_56: G = __r_arr[1];
-            let __v_57: G = __r_arr[2];
-            let __v_58: G = __r_arr[3];
-            let __v_59: G = __r_arr[4];
-            let __v_60: G = __r_arr[5];
-            let __v_61: G = __r_arr[6];
-            let __v_62: G = __r_arr[7];
-            let __v_63: G = __r_arr[8];
-            let __v_64: G = __r_arr[9];
-            let __v_65: G = __r_arr[10];
-            let __v_66: G = __r_arr[11];
-            let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_261] = [__v_67];
+            let __v_50: G = { let __values: [G; 2] = [__v_0, __v_49]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_51: G = G::from_u64(0);
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_51, __v_46, __v_47, __v_50, __v_48]; 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_52: G = __r_arr[0];
+            let __v_53: G = __r_arr[1];
+            let __v_54: G = __r_arr[2];
+            let __v_55: G = __r_arr[3];
+            let __v_56: G = __r_arr[4];
+            let __v_57: G = __r_arr[5];
+            let __v_58: G = __r_arr[6];
+            let __v_59: G = __r_arr[7];
+            let __v_60: G = __r_arr[8];
+            let __v_61: G = __r_arr[9];
+            let __v_62: G = __r_arr[10];
+            let __v_63: G = __r_arr[11];
+            let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_261] = [__v_64];
             record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -25862,7 +25794,7 @@ fn aiur_fn_262(
       _ => {
         match __v_10.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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_729] = { let __args: [G; IN_729] = [__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[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_58: G = __r_arr[0];
             let __v_59: G = __r_arr[1];
             let __v_60: G = __r_arr[2];
@@ -25927,7 +25859,7 @@ fn aiur_fn_262(
                 let __v_114: G = __r_arr[9];
                 let __v_115: G = __r_arr[10];
                 let __v_116: G = __r_arr[11];
-                let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_262] = [__v_117];
                 record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -26074,7 +26006,7 @@ fn aiur_fn_263(
                 let __v_105: G = __r_arr[9];
                 let __v_106: G = __r_arr[10];
                 let __v_107: G = __r_arr[11];
-                let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_263] = [__v_108];
                 record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -26259,7 +26191,7 @@ fn aiur_fn_264(
                     let __v_140: G = __r_arr[9];
                     let __v_141: G = __r_arr[10];
                     let __v_142: G = __r_arr[11];
-                    let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                     let __ret: [G; OUT_264] = [__v_143];
                     record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -26408,7 +26340,7 @@ fn aiur_fn_265(
                 let __v_105: G = __r_arr[9];
                 let __v_106: G = __r_arr[10];
                 let __v_107: G = __r_arr[11];
-                let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_265] = [__v_108];
                 record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -26439,120 +26371,126 @@ fn aiur_fn_266(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: G = __loaded[31];
-    let __v_34: G = __loaded[32];
-    let __v_35: G = __loaded[33];
-    let __v_36: G = __loaded[34];
-    let __v_37: G = __loaded[35];
-    let __v_38: G = __loaded[36];
-    let __v_39: G = __loaded[37];
-    let __v_40: G = __loaded[38];
-    let __v_41: G = __loaded[39];
-    let __v_42: G = __loaded[40];
-    let __v_43: G = __loaded[41];
-    let __v_44: G = __loaded[42];
-    let __v_45: G = __loaded[43];
-    let __v_46: G = __loaded[44];
-    let __v_47: G = __loaded[45];
-    let __v_48: G = __loaded[46];
-    match __v_2.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(1);
+        if (__v_2 != __v_3) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_266] = [__v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2, __v_2];
+        record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __v_11: G = __loaded[9];
+        let __v_12: G = __loaded[10];
+        let __v_13: G = __loaded[11];
+        let __v_14: G = __loaded[12];
+        let __v_15: G = __loaded[13];
+        let __v_16: G = __loaded[14];
+        let __v_17: G = __loaded[15];
+        let __v_18: G = __loaded[16];
+        let __v_19: G = __loaded[17];
+        let __v_20: G = __loaded[18];
+        let __v_21: G = __loaded[19];
+        let __v_22: G = __loaded[20];
+        let __v_23: G = __loaded[21];
+        let __v_24: G = __loaded[22];
+        let __v_25: G = __loaded[23];
+        let __v_26: G = __loaded[24];
+        let __v_27: G = __loaded[25];
+        let __v_28: G = __loaded[26];
+        let __v_29: G = __loaded[27];
+        let __v_30: G = __loaded[28];
+        let __v_31: G = __loaded[29];
+        let __v_32: G = __loaded[30];
+        let __v_33: G = __loaded[31];
+        let __v_34: G = __loaded[32];
+        let __v_35: G = __loaded[33];
+        let __v_36: G = __loaded[34];
+        let __v_37: G = __loaded[35];
+        let __v_38: G = __loaded[36];
+        let __v_39: G = __loaded[37];
+        let __v_40: G = __loaded[38];
+        let __v_41: G = __loaded[39];
+        let __v_42: G = __loaded[40];
+        let __v_43: G = __loaded[41];
+        let __v_44: G = __loaded[42];
+        let __v_45: G = __loaded[43];
+        let __v_46: G = __loaded[44];
+        let __v_47: G = __loaded[45];
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_266] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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 __ret: [G; OUT_266] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_49: G = G::from_u64(1);
-            let __v_50: G = (__v_1 - __v_49);
-            let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_48, __v_50]; 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_51: G = __r_arr[0];
-            let __v_52: G = __r_arr[1];
-            let __v_53: G = __r_arr[2];
-            let __v_54: G = __r_arr[3];
-            let __v_55: G = __r_arr[4];
-            let __v_56: G = __r_arr[5];
-            let __v_57: G = __r_arr[6];
-            let __v_58: G = __r_arr[7];
-            let __v_59: G = __r_arr[8];
-            let __v_60: G = __r_arr[9];
-            let __v_61: G = __r_arr[10];
-            let __v_62: G = __r_arr[11];
-            let __v_63: G = __r_arr[12];
-            let __v_64: G = __r_arr[13];
-            let __v_65: G = __r_arr[14];
-            let __v_66: G = __r_arr[15];
-            let __v_67: G = __r_arr[16];
-            let __v_68: G = __r_arr[17];
-            let __v_69: G = __r_arr[18];
-            let __v_70: G = __r_arr[19];
-            let __v_71: G = __r_arr[20];
-            let __v_72: G = __r_arr[21];
-            let __v_73: G = __r_arr[22];
-            let __v_74: G = __r_arr[23];
-            let __v_75: G = __r_arr[24];
-            let __v_76: G = __r_arr[25];
-            let __v_77: G = __r_arr[26];
-            let __v_78: G = __r_arr[27];
-            let __v_79: G = __r_arr[28];
-            let __v_80: G = __r_arr[29];
-            let __v_81: G = __r_arr[30];
-            let __v_82: G = __r_arr[31];
-            let __v_83: G = __r_arr[32];
-            let __v_84: G = __r_arr[33];
-            let __v_85: G = __r_arr[34];
-            let __v_86: G = __r_arr[35];
-            let __v_87: G = __r_arr[36];
-            let __v_88: G = __r_arr[37];
-            let __v_89: G = __r_arr[38];
-            let __v_90: G = __r_arr[39];
-            let __v_91: G = __r_arr[40];
-            let __v_92: G = __r_arr[41];
-            let __v_93: G = __r_arr[42];
-            let __v_94: G = __r_arr[43];
-            let __v_95: G = __r_arr[44];
-            let __ret: [G; OUT_266] = [__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 __v_48: G = G::from_u64(1);
+            let __v_49: G = (__v_1 - __v_48);
+            let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_47, __v_49]; 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_50: G = __r_arr[0];
+            let __v_51: G = __r_arr[1];
+            let __v_52: G = __r_arr[2];
+            let __v_53: G = __r_arr[3];
+            let __v_54: G = __r_arr[4];
+            let __v_55: G = __r_arr[5];
+            let __v_56: G = __r_arr[6];
+            let __v_57: G = __r_arr[7];
+            let __v_58: G = __r_arr[8];
+            let __v_59: G = __r_arr[9];
+            let __v_60: G = __r_arr[10];
+            let __v_61: G = __r_arr[11];
+            let __v_62: G = __r_arr[12];
+            let __v_63: G = __r_arr[13];
+            let __v_64: G = __r_arr[14];
+            let __v_65: G = __r_arr[15];
+            let __v_66: G = __r_arr[16];
+            let __v_67: G = __r_arr[17];
+            let __v_68: G = __r_arr[18];
+            let __v_69: G = __r_arr[19];
+            let __v_70: G = __r_arr[20];
+            let __v_71: G = __r_arr[21];
+            let __v_72: G = __r_arr[22];
+            let __v_73: G = __r_arr[23];
+            let __v_74: G = __r_arr[24];
+            let __v_75: G = __r_arr[25];
+            let __v_76: G = __r_arr[26];
+            let __v_77: G = __r_arr[27];
+            let __v_78: G = __r_arr[28];
+            let __v_79: G = __r_arr[29];
+            let __v_80: G = __r_arr[30];
+            let __v_81: G = __r_arr[31];
+            let __v_82: G = __r_arr[32];
+            let __v_83: G = __r_arr[33];
+            let __v_84: G = __r_arr[34];
+            let __v_85: G = __r_arr[35];
+            let __v_86: G = __r_arr[36];
+            let __v_87: G = __r_arr[37];
+            let __v_88: G = __r_arr[38];
+            let __v_89: G = __r_arr[39];
+            let __v_90: G = __r_arr[40];
+            let __v_91: G = __r_arr[41];
+            let __v_92: G = __r_arr[42];
+            let __v_93: G = __r_arr[43];
+            let __v_94: G = __r_arr[44];
+            let __ret: [G; OUT_266] = [__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];
             record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -26726,23 +26664,15 @@ fn aiur_fn_268(
     let __v_98: G = __mc_out___mc_0[42];
     let __v_99: G = __mc_out___mc_0[43];
     let __v_100: G = __mc_out___mc_0[44];
-    let __v_101: G = G::from_u64(1);
-    let __v_102: G = G::from_u64(1);
-    let __v_103: G = { let __values: [G; 3] = [__v_101, __v_102, __v_102]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_104: G = G::from_u64(1);
-    let __v_105: G = G::from_u64(1);
-    let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_107: G = G::from_u64(1);
-    let __v_108: G = G::from_u64(1);
-    let __v_109: G = { let __values: [G; 3] = [__v_107, __v_108, __v_108]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_110: G = G::from_u64(1);
-    let __v_111: G = G::from_u64(1);
-    let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
-    let __v_113: G = __r_arr[0];
-    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
-    let __v_114: G = __r_arr[0];
-    let __ret: [G; OUT_268] = [__v_114];
+    let __v_101: G = G::from_u64(0);
+    let __v_102: G = G::from_u64(0);
+    let __v_103: G = G::from_u64(0);
+    let __v_104: G = G::from_u64(0);
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104]; 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_105: G = __r_arr[0];
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_105]; 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 __ret: [G; OUT_268] = [__v_106];
     record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -26783,79 +26713,72 @@ fn aiur_fn_270(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    let __v_8: G = __loaded[4];
-    let __v_9: G = __loaded[5];
-    let __v_10: G = __loaded[6];
-    let __v_11: G = __loaded[7];
-    let __v_12: G = __loaded[8];
-    let __v_13: G = __loaded[9];
-    let __v_14: G = __loaded[10];
-    let __v_15: G = __loaded[11];
-    let __v_16: G = __loaded[12];
-    let __v_17: G = __loaded[13];
-    let __v_18: G = __loaded[14];
-    let __v_19: G = __loaded[15];
-    let __v_20: G = __loaded[16];
-    let __v_21: G = __loaded[17];
-    let __v_22: G = __loaded[18];
-    let __v_23: G = __loaded[19];
-    let __v_24: G = __loaded[20];
-    let __v_25: G = __loaded[21];
-    let __v_26: G = __loaded[22];
-    let __v_27: G = __loaded[23];
-    let __v_28: G = __loaded[24];
-    let __v_29: G = __loaded[25];
-    let __v_30: G = __loaded[26];
-    let __v_31: G = __loaded[27];
-    let __v_32: G = __loaded[28];
-    let __v_33: G = __loaded[29];
-    let __v_34: G = __loaded[30];
-    let __v_35: G = __loaded[31];
-    let __v_36: G = __loaded[32];
-    let __v_37: G = __loaded[33];
-    let __v_38: G = __loaded[34];
-    let __v_39: G = __loaded[35];
-    let __v_40: G = __loaded[36];
-    let __v_41: G = __loaded[37];
-    let __v_42: G = __loaded[38];
-    let __v_43: G = __loaded[39];
-    let __v_44: G = __loaded[40];
-    let __v_45: G = __loaded[41];
-    let __v_46: G = __loaded[42];
-    let __v_47: G = __loaded[43];
-    let __v_48: G = __loaded[44];
-    let __v_49: G = __loaded[45];
-    let __v_50: G = __loaded[46];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __v_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_270] = [__v_53];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_270] = [__v_4];
         record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_51: G = G::from_u64(0);
+      _ => {
+        let __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        let __v_8: G = __loaded[4];
+        let __v_9: G = __loaded[5];
+        let __v_10: G = __loaded[6];
+        let __v_11: G = __loaded[7];
+        let __v_12: G = __loaded[8];
+        let __v_13: G = __loaded[9];
+        let __v_14: G = __loaded[10];
+        let __v_15: G = __loaded[11];
+        let __v_16: G = __loaded[12];
+        let __v_17: G = __loaded[13];
+        let __v_18: G = __loaded[14];
+        let __v_19: G = __loaded[15];
+        let __v_20: G = __loaded[16];
+        let __v_21: G = __loaded[17];
+        let __v_22: G = __loaded[18];
+        let __v_23: G = __loaded[19];
+        let __v_24: G = __loaded[20];
+        let __v_25: G = __loaded[21];
+        let __v_26: G = __loaded[22];
+        let __v_27: G = __loaded[23];
+        let __v_28: G = __loaded[24];
+        let __v_29: G = __loaded[25];
+        let __v_30: G = __loaded[26];
+        let __v_31: G = __loaded[27];
+        let __v_32: G = __loaded[28];
+        let __v_33: G = __loaded[29];
+        let __v_34: G = __loaded[30];
+        let __v_35: G = __loaded[31];
+        let __v_36: G = __loaded[32];
+        let __v_37: G = __loaded[33];
+        let __v_38: G = __loaded[34];
+        let __v_39: G = __loaded[35];
+        let __v_40: G = __loaded[36];
+        let __v_41: G = __loaded[37];
+        let __v_42: G = __loaded[38];
+        let __v_43: G = __loaded[39];
+        let __v_44: G = __loaded[40];
+        let __v_45: G = __loaded[41];
+        let __v_46: G = __loaded[42];
+        let __v_47: G = __loaded[43];
+        let __v_48: G = __loaded[44];
+        let __v_49: G = __loaded[45];
         let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_1, __v_3]; 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_52: G = __r_arr[0];
-        let __v_53: G = G::from_u64(1);
-        let __v_54: G = (__v_3 + __v_53);
-        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_0, __v_1, __v_50, __v_54]; 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_55: G = __r_arr[0];
-        let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_270] = [__v_56];
+        let __v_50: G = __r_arr[0];
+        let __v_51: G = G::from_u64(1);
+        let __v_52: G = (__v_3 + __v_51);
+        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_0, __v_1, __v_49, __v_52]; 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_53: G = __r_arr[0];
+        let __v_54: G = { let __values: [G; 2] = [__v_50, __v_53]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_270] = [__v_54];
         record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
     }
   })
 }
@@ -26871,7 +26794,7 @@ fn aiur_fn_271(
 ) -> Result<[G; OUT_271], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -26950,13 +26873,13 @@ fn aiur_fn_272(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -26976,7 +26899,7 @@ fn aiur_fn_272(
         }
       },
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -26997,7 +26920,7 @@ fn aiur_fn_272(
         }
       },
       2u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -27021,7 +26944,7 @@ fn aiur_fn_272(
         }
       },
       3u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -27045,7 +26968,7 @@ fn aiur_fn_272(
         }
       },
       4u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -27084,89 +27007,74 @@ fn aiur_fn_273(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_273] = [__v_8];
-            record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_273] = [__v_8];
+            let __v_2: G = G::from_u64(0);
+            let __ret: [G; OUT_273] = [__v_2];
             record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            let __v_2: G = G::from_u64(1);
+            let __ret: [G; OUT_273] = [__v_2];
+            record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_273] = [__v_8];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(2);
+            let __ret: [G; OUT_273] = [__v_4];
             record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-            match __v_8.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_4: G = __loaded[0];
+            let __v_5: G = __loaded[1];
+            let __v_6: G = { let __a_val = __v_2.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_6.as_canonical_u64() {
               1u64 => {
-                let __v_9: G = G::from_u64(1);
-                let __ret: [G; OUT_273] = [__v_9];
+                let __v_7: G = G::from_u64(1);
+                let __ret: [G; OUT_273] = [__v_7];
                 record.function_queries[273].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() {
+                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 __v_10: G = G::from_u64(2);
-                    let __ret: [G; OUT_273] = [__v_10];
+                    let __v_8: G = G::from_u64(2);
+                    let __ret: [G; OUT_273] = [__v_8];
                     record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
-                    let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_273] = [__v_10];
+                    let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
+                    let __v_8: G = __r_arr[0];
+                    let __ret: [G; OUT_273] = [__v_8];
                     record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
                   },
                 }
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -27183,73 +27091,65 @@ fn aiur_fn_274(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_274] = [__v_5];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_274] = [__v_2];
         record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_274] = [__v_8];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_274] = [__v_4];
             record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-            match __v_8.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_4: G = __loaded[0];
+            let __v_5: G = __loaded[1];
+            let __v_6: G = { let __a_val = __v_2.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_6.as_canonical_u64() {
               1u64 => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_274] = [__v_9];
+                let __v_7: G = G::from_u64(0);
+                let __ret: [G; OUT_274] = [__v_7];
                 record.function_queries[274].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() {
+                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 __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_0, __v_7]; 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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_274] = [__v_10];
+                    let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
+                    let __v_8: G = __r_arr[0];
+                    let __ret: [G; OUT_274] = [__v_8];
                     record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_4, __v_7]; 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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_274] = [__v_10];
+                    let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
+                    let __v_8: G = __r_arr[0];
+                    let __ret: [G; OUT_274] = [__v_8];
                     record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
                   },
                 }
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -27266,61 +27166,46 @@ fn aiur_fn_275(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_275] = [__v_8];
-            record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_275] = [__v_8];
+            let __v_2: G = G::from_u64(1);
+            let __ret: [G; OUT_275] = [__v_2];
             record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
-      },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_275] = [__v_8];
+            let __v_2: G = G::from_u64(0);
+            let __ret: [G; OUT_275] = [__v_2];
             record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
+        }
+      },
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_4, __v_7]; 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_275] = [__v_8];
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_275] = [__v_4];
             record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_4: G = __loaded[0];
+            let __v_5: G = __loaded[1];
+            let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
+            let __ret: [G; OUT_275] = [__v_6];
+            record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -27337,65 +27222,56 @@ fn aiur_fn_276(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_276] = [__v_5, __v_10];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = { let __values: [G; 2] = [__v_0, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_276] = [__v_2, __v_4];
         record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-        match __v_5.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: 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_4.as_canonical_u64() {
           1u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = G::from_u64(0);
-            let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_276] = [__v_6, __v_8];
+            let __v_5: G = G::from_u64(1);
+            let __v_6: G = { let __values: [G; 2] = [__v_0, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_276] = [__v_5, __v_6];
             record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_0.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-            match __v_6.as_canonical_u64() {
+            let __v_5: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_0.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+            match __v_5.as_canonical_u64() {
               0u64 => {
-                let __v_7: G = G::from_u64(0);
-                let __ret: [G; OUT_276] = [__v_7, __v_1];
+                let __v_6: G = G::from_u64(0);
+                let __ret: [G; OUT_276] = [__v_6, __v_1];
                 record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
-                let __v_7: G = __r_arr[0];
-                let __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_276] = [__v_7, __v_10];
+                let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
+                let __v_6: G = __r_arr[0];
+                let __v_7: G = __r_arr[1];
+                let __v_8: G = { let __values: [G; 2] = [__v_2, __v_7]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_276] = [__v_6, __v_8];
                 record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -27413,58 +27289,51 @@ fn aiur_fn_277(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_277] = [__v_11];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_3: 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = { let __values: [G; 2] = [__v_3, __v_4]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_277] = [__v_5];
         record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        match __v_6.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        match __v_5.as_canonical_u64() {
           _ => {
-            let __v_8: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-            match __v_8.as_canonical_u64() {
+            let __v_7: 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_7.as_canonical_u64() {
               1u64 => {
-                let __v_9: G = G::from_u64(0);
-                let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_277] = [__v_11];
+                let __v_8: 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_9: G = { let __values: [G; 2] = [__v_8, __v_0]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_277] = [__v_9];
                 record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                match __v_9.as_canonical_u64() {
+                let __v_8: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                match __v_8.as_canonical_u64() {
                   1u64 => {
-                    let __v_10: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_5, __v_1, __v_2]; 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_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_277] = [__v_12];
+                    let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } };
+                    let __v_9: G = __r_arr[0];
+                    let __v_10: G = { let __values: [G; 2] = [__v_3, __v_9]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __ret: [G; OUT_277] = [__v_10];
                     record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                    match __v_10.as_canonical_u64() {
+                    let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                    match __v_9.as_canonical_u64() {
                       1u64 => {
-                        let __v_11: G = G::from_u64(0);
-                        let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_277] = [__v_13];
+                        let __v_10: G = { let __values: [G; 2] = [__v_5, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_11: G = { let __values: [G; 2] = [__v_10, __v_4]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __ret: [G; OUT_277] = [__v_11];
                         record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
@@ -27474,25 +27343,22 @@ fn aiur_fn_277(
                         return Ok(__ret);
                       },
                       _ => {
-                        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+                        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
                       },
                     }
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
                   },
                 }
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
               },
             }
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -27509,80 +27375,71 @@ fn aiur_fn_278(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_278] = [__v_8];
-            record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_278] = [__v_8];
+            let __v_2: G = G::from_u64(1);
+            let __ret: [G; OUT_278] = [__v_2];
             record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            let __v_2: G = G::from_u64(0);
+            let __ret: [G; OUT_278] = [__v_2];
+            record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_278] = [__v_8];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_278] = [__v_4];
             record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-            let __v_8: G = __loaded[0];
-            let __v_9: G = __loaded[1];
-            match __v_8.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_4: G = __loaded[0];
+            let __v_5: G = __loaded[1];
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_6: G = __loaded[0];
+            let __v_7: G = __loaded[1];
+            match __v_6.as_canonical_u64() {
               _ => {
-                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-                let __v_10: G = __loaded[0];
-                let __v_11: G = __loaded[1];
-                match __v_10.as_canonical_u64() {
+                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                let __v_8: G = __loaded[0];
+                let __v_9: G = __loaded[1];
+                match __v_8.as_canonical_u64() {
                   _ => {
-                    let __v_12: G = (__v_8 - __v_10);
-                    match __v_12.as_canonical_u64() {
+                    let __v_10: G = (__v_6 - __v_8);
+                    match __v_10.as_canonical_u64() {
                       0u64 => {
-                        let __v_13: G = (__v_9 - __v_11);
-                        match __v_13.as_canonical_u64() {
+                        let __v_11: G = (__v_7 - __v_9);
+                        match __v_11.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
-                            let __v_14: G = __r_arr[0];
-                            let __ret: [G; OUT_278] = [__v_14];
+                            let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_3, __v_5]; 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_12: G = __r_arr[0];
+                            let __ret: [G; OUT_278] = [__v_12];
                             record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
-                            let __v_14: G = G::from_u64(0);
-                            let __ret: [G; OUT_278] = [__v_14];
+                            let __v_12: G = G::from_u64(0);
+                            let __ret: [G; OUT_278] = [__v_12];
                             record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        let __v_13: G = G::from_u64(0);
-                        let __ret: [G; OUT_278] = [__v_13];
+                        let __v_11: G = G::from_u64(0);
+                        let __ret: [G; OUT_278] = [__v_11];
                         record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
@@ -27592,14 +27449,8 @@ fn aiur_fn_278(
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -27615,47 +27466,43 @@ fn aiur_fn_279(
 ) -> Result<[G; OUT_279], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_279] = [__v_4];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_279] = [__v_1];
         record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-        let __v_4: G = __loaded[0];
-        let __v_5: G = __loaded[1];
-        match __v_4.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        match __v_3.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
-            let __v_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() {
+            let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
+            let __v_5: G = __r_arr[0];
+            let __v_6: G = { let __a_val = __v_5.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_6.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_279] = [__v_5];
+                let __ret: [G; OUT_279] = [__v_4];
                 record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __ret: [G; OUT_279] = [__v_6];
+                let __ret: [G; OUT_279] = [__v_5];
                 record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
               },
             }
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -27672,90 +27519,86 @@ fn aiur_fn_280(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_280] = [__v_0];
         record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
             let __ret: [G; OUT_280] = [__v_0];
             record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-            let __v_8: G = __loaded[0];
-            let __v_9: G = __loaded[1];
-            match __v_8.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_4: G = __loaded[0];
+            let __v_5: G = __loaded[1];
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_6: G = __loaded[0];
+            let __v_7: G = __loaded[1];
+            match __v_6.as_canonical_u64() {
               _ => {
-                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-                let __v_10: G = __loaded[0];
-                let __v_11: G = __loaded[1];
-                match __v_10.as_canonical_u64() {
+                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                let __v_8: G = __loaded[0];
+                let __v_9: G = __loaded[1];
+                match __v_8.as_canonical_u64() {
                   _ => {
-                    let __v_12: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                    match __v_12.as_canonical_u64() {
+                    let __v_10: G = { let __a_val = __v_6.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_10.as_canonical_u64() {
                       1u64 => {
-                        let __v_13: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_4, __v_1]; 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_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_280] = [__v_15];
+                        let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+                        let __v_11: G = __r_arr[0];
+                        let __v_12: G = { let __values: [G; 2] = [__v_2, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __ret: [G; OUT_280] = [__v_12];
                         record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       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() {
+                        let __v_11: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                        match __v_11.as_canonical_u64() {
                           1u64 => {
-                            let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_0, __v_7]; 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_14: G = __r_arr[0];
-                            let __ret: [G; OUT_280] = [__v_14];
+                            let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+                            let __v_12: G = __r_arr[0];
+                            let __ret: [G; OUT_280] = [__v_12];
                             record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           0u64 => {
-                            let __v_14: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_9.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                            match __v_14.as_canonical_u64() {
+                            let __v_12: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                            match __v_12.as_canonical_u64() {
                               1u64 => {
-                                let __v_15: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_4, __v_7]; 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_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_280] = [__v_17];
+                                let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+                                let __v_13: G = __r_arr[0];
+                                let __v_14: G = { let __values: [G; 2] = [__v_2, __v_13]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __ret: [G; OUT_280] = [__v_14];
                                 record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
-                                let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_4, __v_7]; 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_15: G = __r_arr[0];
-                                let __ret: [G; OUT_280] = [__v_15];
+                                let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+                                let __v_13: G = __r_arr[0];
+                                let __ret: [G; OUT_280] = [__v_13];
                                 record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
-                                return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+                                return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
                               },
                             }
                           },
                           _ => {
-                            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+                            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
                           },
                         }
                       },
                       _ => {
-                        return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+                        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
                       },
                     }
                   },
@@ -27763,14 +27606,8 @@ fn aiur_fn_280(
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -27795,26 +27632,19 @@ fn aiur_fn_281(
         return Ok(__ret);
       },
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_3: G = __loaded[0];
-        let __v_4: G = __loaded[1];
-        let __v_5: G = __loaded[2];
-        match __v_3.as_canonical_u64() {
-          1u64 => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
             let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0, __v_1, __v_2]; 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_281] = [__v_6];
+            let __v_3: G = __r_arr[0];
+            let __ret: [G; OUT_281] = [__v_3];
             record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
+          _ => {
             let __ret: [G; OUT_281] = [__v_0];
             record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-          },
         }
       },
       _ => {
@@ -27841,43 +27671,36 @@ fn aiur_fn_282(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_10: G = { let __values: [G; 3] = [__v_1, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_282] = [__v_14];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = { let __values: [G; 3] = [__v_1, __v_2, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = { let __values: [G; 2] = [__v_4, __v_5]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_282] = [__v_6];
         record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_1, __v_6]; 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_9: G = __r_arr[0];
-            match __v_9.as_canonical_u64() {
+            let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            match __v_8.as_canonical_u64() {
               0u64 => {
-                let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                match __v_10.as_canonical_u64() {
+                let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __v_11: G = G::from_u64(0);
-                    let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_282] = [__v_13];
+                    let __v_10: G = { let __values: [G; 3] = [__v_5, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_11: G = { let __values: [G; 2] = [__v_10, __v_4]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __ret: [G; OUT_282] = [__v_11];
                     record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
@@ -27887,27 +27710,23 @@ fn aiur_fn_282(
                     return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
                   },
                 }
               },
               1u64 => {
-                let __v_10: G = G::from_u64(0);
-                let __v_11: G = G::from_u64(1);
-                let __v_12: G = G::from_u64(1);
-                let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_282] = [__v_15];
+                let __v_9: G = G::from_u64(0);
+                let __v_10: G = { let __values: [G; 3] = [__v_1, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_11: G = { let __values: [G; 2] = [__v_10, __v_0]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_282] = [__v_11];
                 record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
-                let __v_11: G = __r_arr[0];
-                let __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_282] = [__v_12];
+                let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __v_10: G = { let __values: [G; 2] = [__v_3, __v_9]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_282] = [__v_10];
                 record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -27915,9 +27734,6 @@ fn aiur_fn_282(
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -27936,70 +27752,57 @@ fn aiur_fn_283(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(0);
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = { let __values: [G; 2] = [__v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_8: G = { let __values: [G; 3] = [__v_1, __v_4, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_15: G = { let __values: [G; 3] = [__v_1, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_16: G = G::from_u64(1);
-        let __v_17: G = G::from_u64(1);
-        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_283] = [__v_19];
+        let __v_10: G = { let __values: [G; 2] = [__v_8, __v_9]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_283] = [__v_10];
         record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        match __v_7.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            match __v_10.as_canonical_u64() {
+            let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_1, __v_6]; 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_9: G = __r_arr[0];
+            match __v_9.as_canonical_u64() {
               0u64 => {
-                let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } };
-                let __v_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_283] = [__v_14];
+                let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } };
+                let __v_10: G = __r_arr[0];
+                let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_12: G = { let __values: [G; 2] = [__v_11, __v_5]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_283] = [__v_12];
                 record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __v_11: G = G::from_u64(0);
+                let __v_10: G = G::from_u64(0);
+                let __v_11: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_12: G = G::from_u64(0);
-                let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_15: G = G::from_u64(1);
-                let __v_16: G = G::from_u64(1);
-                let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_283] = [__v_20];
+                let __v_13: G = { let __values: [G; 2] = [__v_11, __v_12]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_14: G = { let __values: [G; 3] = [__v_1, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_15: G = { let __values: [G; 2] = [__v_14, __v_0]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_283] = [__v_15];
                 record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
-                let __v_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_283] = [__v_13];
+                let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+                let __v_10: G = __r_arr[0];
+                let __v_11: G = { let __values: [G; 2] = [__v_4, __v_10]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_283] = [__v_11];
                 record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -28007,9 +27810,6 @@ fn aiur_fn_283(
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
     }
   })
 }
@@ -28028,7 +27828,7 @@ fn aiur_fn_284(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -28122,7 +27922,7 @@ fn aiur_fn_285(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -28222,30 +28022,25 @@ fn aiur_fn_286(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_286] = [__v_0];
         record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_4, __v_1]; 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_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_286] = [__v_8];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2, __v_1]; 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_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = { let __values: [G; 2] = [__v_4, __v_5]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_286] = [__v_6];
         record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -28262,133 +28057,118 @@ fn aiur_fn_287(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_287] = [__v_0];
         record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
           _ => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_8: G = __loaded[0];
-            let __v_9: G = __loaded[1];
-            let __v_10: G = __loaded[2];
-            match __v_8.as_canonical_u64() {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            match __v_7.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_8, __v_5]; 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];
-                match __v_11.as_canonical_u64() {
+                let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
+                let __v_10: G = __r_arr[0];
+                match __v_10.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
-                    let __v_12: G = __r_arr[0];
-                    let __ret: [G; OUT_287] = [__v_12];
+                    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_3]; 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_11: G = __r_arr[0];
+                    let __ret: [G; OUT_287] = [__v_11];
                     record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
-                    let __v_12: G = __r_arr[0];
-                    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
+                    let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
+                    let __v_11: G = __r_arr[0];
+                    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_5.as_canonical_u64() {
   0u64 => {
-    let __v_13: G = G::from_u64(0);
-    break '__mc_0 [__v_13];
+    let __v_12: G = G::from_u64(0);
+    break '__mc_0 [__v_12];
   },
   _ => {
-    let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_12.as_canonical_u64() {
+    let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() {
   1u64 => {
-    let __v_13: G = G::from_u64(1);
-    break '__mc_1 [__v_13];
+    let __v_12: G = G::from_u64(1);
+    break '__mc_1 [__v_12];
   },
   0u64 => {
-    let __v_13: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-    break '__mc_1 [__v_13];
+    let __v_12: G = { let __a_val = __v_8.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 };
+    break '__mc_1 [__v_12];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+    return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
   },
 }
  };
-    let __v_13: G = __mc_out___mc_1[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_14: G = __loaded[0];
-    let __v_15: G = __loaded[1];
-    let __v_16: G = __loaded[2];
-    let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_14.as_canonical_u64() {
-  1u64 => {
-    let __v_17: G = G::from_u64(1);
-    break '__mc_2 [__v_17];
-  },
+    let __v_12: G = __mc_out___mc_1[0];
+    let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_9.as_canonical_u64() {
   0u64 => {
-    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
-    let __v_17: G = __r_arr[0];
-    let __v_18: G = G::from_u64(1);
-    let __v_19: G = (__v_17 + __v_18);
-    let __v_20: G = { let __a_val = __v_19.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-    break '__mc_2 [__v_20];
+    let __v_13: G = G::from_u64(1);
+    break '__mc_2 [__v_13];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_6]; 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_13: G = __r_arr[0];
+    let __v_14: G = G::from_u64(1);
+    let __v_15: G = (__v_13 + __v_14);
+    let __v_16: G = { let __a_val = __v_15.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 };
+    break '__mc_2 [__v_16];
   },
 }
  };
-    let __v_17: G = __mc_out___mc_2[0];
-    let __v_18: G = (__v_13 * __v_17);
-    match __v_18.as_canonical_u64() {
+    let __v_13: G = __mc_out___mc_2[0];
+    let __v_14: G = (__v_12 * __v_13);
+    match __v_14.as_canonical_u64() {
       0u64 => {
-        let __v_19: G = G::from_u64(0);
-        break '__mc_0 [__v_19];
+        let __v_15: G = G::from_u64(0);
+        break '__mc_0 [__v_15];
       },
       _ => {
-        break '__mc_0 [__v_6];
+        break '__mc_0 [__v_5];
       },
     }
   },
 }
  };
-                    let __v_13: G = __mc_out___mc_0[0];
-                    let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_12.as_canonical_u64() {
+                    let __v_12: G = __mc_out___mc_0[0];
+                    let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_11.as_canonical_u64() {
   1u64 => {
-    break '__mc_3 [__v_7];
+    break '__mc_3 [__v_6];
   },
   0u64 => {
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_14: G = __loaded[0];
-    let __v_15: G = __loaded[1];
-    let __v_16: G = __loaded[2];
-    match __v_14.as_canonical_u64() {
-      1u64 => {
-        break '__mc_3 [__v_7];
-      },
+    match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_7, __v_10]; 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];
-        break '__mc_3 [__v_17];
+        break '__mc_3 [__v_6];
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+        let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        break '__mc_3 [__v_13];
       },
     }
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+    return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
   },
 }
  };
-                    let __v_14: G = __mc_out___mc_3[0];
-                    let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_15, __v_4]; 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_16: G = __r_arr[0];
-                    let __ret: [G; OUT_287] = [__v_16];
+                    let __v_13: G = __mc_out___mc_3[0];
+                    let __v_14: G = { let __values: [G; 3] = [__v_4, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_14, __v_3]; 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_15: G = __r_arr[0];
+                    let __ret: [G; OUT_287] = [__v_15];
                     record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
@@ -28398,9 +28178,6 @@ fn aiur_fn_287(
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -28416,45 +28193,37 @@ fn aiur_fn_288(
 ) -> Result<[G; OUT_288], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_288] = [__v_0];
         record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_4: G = __loaded[0];
-        let __v_5: G = __loaded[1];
-        let __v_6: G = __loaded[2];
-        match __v_4.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        match __v_3.as_canonical_u64() {
           _ => {
-            match __v_5.as_canonical_u64() {
+            match __v_4.as_canonical_u64() {
               0u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                let __v_7: G = __loaded[0];
-                let __v_8: G = __loaded[1];
-                let __v_9: G = __loaded[2];
-                match __v_7.as_canonical_u64() {
-                  1u64 => {
-                    let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
-                    let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_288] = [__v_10];
+                match __v_5.as_canonical_u64() {
+                  0u64 => {
+                    let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+                    let __v_6: G = __r_arr[0];
+                    let __ret: [G; OUT_288] = [__v_6];
                     record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
-                  0u64 => {
+                  _ => {
                     let __ret: [G; OUT_288] = [__v_0];
                     record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-                  },
                 }
               },
               _ => {
@@ -28466,9 +28235,6 @@ fn aiur_fn_288(
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -28489,98 +28255,89 @@ fn aiur_fn_289(
     let __v_2: G = __r_arr[0];
     let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        match __v_7.as_canonical_u64() {
-          1u64 => {
-            let __v_10: G = G::from_u64(1);
-            let __ret: [G; OUT_289] = [__v_10];
-            record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        match __v_3.as_canonical_u64() {
           0u64 => {
-            let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_289] = [__v_10];
+            let __v_4: G = G::from_u64(1);
+            let __ret: [G; OUT_289] = [__v_4];
             record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_289] = [__v_4];
+            record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        match __v_7.as_canonical_u64() {
-          1u64 => {
-            let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_289] = [__v_10];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        match __v_3.as_canonical_u64() {
+          0u64 => {
+            let __v_6: G = G::from_u64(0);
+            let __ret: [G; OUT_289] = [__v_6];
             record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_10: G = __loaded[0];
-            let __v_11: G = __loaded[1];
-            let __v_12: G = __loaded[2];
-            match __v_10.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_6: G = __loaded[0];
+            let __v_7: G = __loaded[1];
+            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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_8: G = __loaded[0];
+            let __v_9: G = __loaded[1];
+            let __v_10: G = __loaded[2];
+            match __v_8.as_canonical_u64() {
               _ => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                let __v_13: G = __loaded[0];
-                let __v_14: G = __loaded[1];
-                let __v_15: G = __loaded[2];
-                match __v_13.as_canonical_u64() {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_11: G = __loaded[0];
+                let __v_12: G = __loaded[1];
+                let __v_13: G = __loaded[2];
+                match __v_11.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_10, __v_13]; 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_16: G = __r_arr[0];
-                    match __v_16.as_canonical_u64() {
+                    let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
+                    let __v_14: G = __r_arr[0];
+                    match __v_14.as_canonical_u64() {
                       0u64 => {
-                        let __v_17: G = (__v_11 - __v_14);
-                        match __v_17.as_canonical_u64() {
+                        let __v_15: G = (__v_9 - __v_12);
+                        match __v_15.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_12, __v_15]; 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_18: G = __r_arr[0];
-                            match __v_18.as_canonical_u64() {
+                            let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+                            let __v_16: G = __r_arr[0];
+                            match __v_16.as_canonical_u64() {
                               1u64 => {
-                                let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_6, __v_9]; 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_19: G = __r_arr[0];
-                                let __ret: [G; OUT_289] = [__v_19];
+                                let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+                                let __v_17: G = __r_arr[0];
+                                let __ret: [G; OUT_289] = [__v_17];
                                 record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               0u64 => {
-                                let __v_19: G = G::from_u64(0);
-                                let __ret: [G; OUT_289] = [__v_19];
+                                let __v_17: G = G::from_u64(0);
+                                let __ret: [G; OUT_289] = [__v_17];
                                 record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
-                                return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+                                return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
                               },
                             }
                           },
                           _ => {
-                            let __v_18: G = G::from_u64(0);
-                            let __ret: [G; OUT_289] = [__v_18];
+                            let __v_16: G = G::from_u64(0);
+                            let __ret: [G; OUT_289] = [__v_16];
                             record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        let __v_17: G = G::from_u64(0);
-                        let __ret: [G; OUT_289] = [__v_17];
+                        let __v_15: G = G::from_u64(0);
+                        let __ret: [G; OUT_289] = [__v_15];
                         record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
@@ -28590,14 +28347,8 @@ fn aiur_fn_289(
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
     }
   })
 }
@@ -28615,68 +28366,67 @@ fn aiur_fn_290(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_290] = [__v_6];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_290] = [__v_3];
         record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            match __v_9.as_canonical_u64() {
+            let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            match __v_8.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
-                let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_290] = [__v_10];
+                let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __ret: [G; OUT_290] = [__v_9];
                 record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() {
+                let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() {
   0u64 => {
-    let __v_11: G = G::from_u64(1);
-    break '__mc_0 [__v_11];
+    let __v_10: G = G::from_u64(1);
+    break '__mc_0 [__v_10];
   },
   1u64 => {
-    let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_8, __v_2]; 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_11: G = __r_arr[0];
-    break '__mc_0 [__v_11];
+    let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    break '__mc_0 [__v_10];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
   },
 }
  };
-                let __v_11: G = __mc_out___mc_0[0];
-                match __v_11.as_canonical_u64() {
+                let __v_10: G = __mc_out___mc_0[0];
+                match __v_10.as_canonical_u64() {
                   1u64 => {
-                    let __v_12: G = G::from_u64(1);
-                    let __ret: [G; OUT_290] = [__v_12];
+                    let __v_11: G = G::from_u64(1);
+                    let __ret: [G; OUT_290] = [__v_11];
                     record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
-                    let __v_12: G = __r_arr[0];
-                    let __ret: [G; OUT_290] = [__v_12];
+                    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+                    let __v_11: G = __r_arr[0];
+                    let __ret: [G; OUT_290] = [__v_11];
                     record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
                   },
                 }
               },
@@ -28684,9 +28434,6 @@ fn aiur_fn_290(
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -28703,50 +28450,46 @@ fn aiur_fn_291(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_291] = [__v_5];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_291] = [__v_2];
         record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        match __v_5.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        match __v_4.as_canonical_u64() {
           _ => {
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = (__v_6 + __v_7);
-            let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-            match __v_9.as_canonical_u64() {
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_5 + __v_6);
+            let __v_8: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+            match __v_8.as_canonical_u64() {
               0u64 => {
-                let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_291] = [__v_10];
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_291] = [__v_9];
                 record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
-                let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_291] = [__v_10];
+                let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __ret: [G; OUT_291] = [__v_9];
                 record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
               },
             }
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -28765,53 +28508,52 @@ fn aiur_fn_292(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_292] = [__v_7];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_292] = [__v_4];
         record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        match __v_7.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            match __v_10.as_canonical_u64() {
+            let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            match __v_9.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_6, __v_1, __v_2, __v_3]; 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_292] = [__v_11];
+                let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_5, __v_1, __v_2, __v_3]; 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_10: G = __r_arr[0];
+                let __ret: [G; OUT_292] = [__v_10];
                 record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_9, __v_2, __v_3]; 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_11: G = __r_arr[0];
-                match __v_11.as_canonical_u64() {
+                let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_8, __v_2, __v_3]; 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_10: G = __r_arr[0];
+                match __v_10.as_canonical_u64() {
                   1u64 => {
-                    let __v_12: G = G::from_u64(1);
-                    let __ret: [G; OUT_292] = [__v_12];
+                    let __v_11: G = G::from_u64(1);
+                    let __ret: [G; OUT_292] = [__v_11];
                     record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_6, __v_1, __v_2, __v_3]; 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_12: G = __r_arr[0];
-                    let __ret: [G; OUT_292] = [__v_12];
+                    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_5, __v_1, __v_2, __v_3]; 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_11: G = __r_arr[0];
+                    let __ret: [G; OUT_292] = [__v_11];
                     record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
                   },
                 }
               },
@@ -28819,9 +28561,6 @@ fn aiur_fn_292(
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
     }
   })
 }
@@ -28839,50 +28578,49 @@ fn aiur_fn_293(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_293] = [__v_6];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_293] = [__v_3];
         record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        match __v_6.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        match __v_5.as_canonical_u64() {
           _ => {
-            let __v_8: G = (__v_6 - __v_1);
-            match __v_8.as_canonical_u64() {
+            let __v_7: G = (__v_5 - __v_1);
+            match __v_7.as_canonical_u64() {
               0u64 => {
-                let __v_9: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                match __v_9.as_canonical_u64() {
+                let __v_8: G = { let __a_val = __v_6.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_8.as_canonical_u64() {
                   0u64 => {
-                    let __v_10: G = G::from_u64(1);
-                    let __ret: [G; OUT_293] = [__v_10];
+                    let __v_9: G = G::from_u64(1);
+                    let __ret: [G; OUT_293] = [__v_9];
                     record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_5, __v_1, __v_2]; 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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_293] = [__v_10];
+                    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_4, __v_1, __v_2]; 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_9: G = __r_arr[0];
+                    let __ret: [G; OUT_293] = [__v_9];
                     record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_5, __v_1, __v_2]; 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_293] = [__v_9];
+                let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_4, __v_1, __v_2]; 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_8: G = __r_arr[0];
+                let __ret: [G; OUT_293] = [__v_8];
                 record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -28890,9 +28628,6 @@ fn aiur_fn_293(
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -28909,76 +28644,72 @@ fn aiur_fn_294(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_294] = [__v_5];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_294] = [__v_2];
         record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
           _ => {
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_5.as_canonical_u64() {
   0u64 => {
-    let __v_8: G = G::from_u64(1);
-    break '__mc_0 [__v_8];
+    let __v_7: G = G::from_u64(1);
+    break '__mc_0 [__v_7];
   },
   _ => {
-    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1, __v_5, __v_6]; 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_8: G = __r_arr[0];
-    break '__mc_0 [__v_8];
+    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1, __v_4, __v_5]; 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_7: G = __r_arr[0];
+    break '__mc_0 [__v_7];
   },
 }
  };
-            let __v_8: G = __mc_out___mc_0[0];
-            match __v_8.as_canonical_u64() {
+            let __v_7: G = __mc_out___mc_0[0];
+            match __v_7.as_canonical_u64() {
               0u64 => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_294] = [__v_9];
+                let __v_8: G = G::from_u64(0);
+                let __ret: [G; OUT_294] = [__v_8];
                 record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
-                let __v_9: G = __r_arr[0];
-                match __v_9.as_canonical_u64() {
+                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_6, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+                let __v_8: G = __r_arr[0];
+                match __v_8.as_canonical_u64() {
                   0u64 => {
-                    let __v_10: G = G::from_u64(0);
-                    let __ret: [G; OUT_294] = [__v_10];
+                    let __v_9: G = G::from_u64(0);
+                    let __ret: [G; OUT_294] = [__v_9];
                     record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
-                    let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_294] = [__v_10];
+                    let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+                    let __v_9: G = __r_arr[0];
+                    let __ret: [G; OUT_294] = [__v_9];
                     record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
                   },
                 }
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
               },
             }
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -28996,49 +28727,45 @@ fn aiur_fn_295(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_295] = [__v_6];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_295] = [__v_3];
         record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        match __v_6.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        match __v_5.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_1, __v_2, __v_6, __v_7]; 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_8: G = __r_arr[0];
-            match __v_8.as_canonical_u64() {
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            match __v_7.as_canonical_u64() {
               0u64 => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_295] = [__v_9];
+                let __v_8: G = G::from_u64(0);
+                let __ret: [G; OUT_295] = [__v_8];
                 record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
-                let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_295] = [__v_9];
+                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+                let __v_8: G = __r_arr[0];
+                let __ret: [G; OUT_295] = [__v_8];
                 record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
               },
             }
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -29055,27 +28782,18 @@ fn aiur_fn_296(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
-    let __v_2: G = G::from_u64(1);
-    let __v_3: G = G::from_u64(1);
-    let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_2: G = G::from_u64(0);
+    let __v_3: G = G::from_u64(0);
+    let __v_4: G = { let __values: [G; 3] = [__v_1, __v_2, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_5: G = G::from_u64(0);
-    let __v_6: G = G::from_u64(1);
-    let __v_7: G = G::from_u64(1);
-    let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_9: G = { let __values: [G; 3] = [__v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_10: G = G::from_u64(1);
-    let __v_11: G = G::from_u64(1);
-    let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_13: G = { let __values: [G; 3] = [__v_1, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_14: G = G::from_u64(1);
-    let __v_15: G = G::from_u64(1);
-    let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_17: G = G::from_u64(0);
-    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0, __v_16, __v_17, __v_13]; 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_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_18, __v_18]; 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_19: G = __r_arr[0];
-    let __ret: [G; OUT_296] = [__v_19];
+    let __v_6: G = { let __values: [G; 2] = [__v_4, __v_5]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_7: G = G::from_u64(0);
+    let __v_8: G = G::from_u64(0);
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0, __v_7, __v_8, __v_6]; 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_9: G = __r_arr[0];
+    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_9, __v_9]; 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_10: G = __r_arr[0];
+    let __ret: [G; OUT_296] = [__v_10];
     record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -29103,7 +28821,7 @@ fn aiur_fn_297(
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_3: G = __loaded[0];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
@@ -29253,7 +28971,7 @@ fn aiur_fn_300(
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_3: G = __loaded[0];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
@@ -29264,7 +28982,7 @@ fn aiur_fn_300(
             return Ok(__ret);
           },
           _ => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
@@ -29341,13 +29059,13 @@ fn aiur_fn_301(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_3: G = __loaded[0];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
@@ -29367,7 +29085,7 @@ fn aiur_fn_301(
             }
           },
           1u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
@@ -29388,7 +29106,7 @@ fn aiur_fn_301(
             }
           },
           2u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
@@ -29412,7 +29130,7 @@ fn aiur_fn_301(
             }
           },
           3u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
@@ -29436,7 +29154,7 @@ fn aiur_fn_301(
             }
           },
           4u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
@@ -29487,7 +29205,7 @@ fn aiur_fn_302(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -29567,7 +29285,7 @@ fn aiur_fn_303(
       },
       0u64 => {
         let __v_9: G = G::from_u64(2);
-        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_303] = [__v_10];
         record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -29590,7 +29308,7 @@ fn aiur_fn_304(
 ) -> Result<[G; OUT_304], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -29647,7 +29365,7 @@ fn aiur_fn_305(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -29683,7 +29401,7 @@ fn aiur_fn_306(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -29691,7 +29409,7 @@ fn aiur_fn_306(
       0u64 => {
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_306] = [__v_7];
         record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -29715,7 +29433,7 @@ fn aiur_fn_306(
             return Ok(__ret);
           },
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
@@ -29736,7 +29454,7 @@ fn aiur_fn_306(
                   },
                   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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                     let __ret: [G; OUT_306] = [__v_11];
                     record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -29768,7 +29486,7 @@ fn aiur_fn_307(
 ) -> Result<[G; OUT_307], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -29776,7 +29494,7 @@ fn aiur_fn_307(
       0u64 => {
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_307] = [__v_6];
         record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -29784,7 +29502,7 @@ fn aiur_fn_307(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_307] = [__v_6];
         record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -29794,7 +29512,7 @@ fn aiur_fn_307(
         let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__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 __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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_307] = [__v_7];
         record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -29840,7 +29558,7 @@ fn aiur_fn_308(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -29848,7 +29566,7 @@ fn aiur_fn_308(
       0u64 => {
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_308] = [__v_7];
         record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -29858,7 +29576,7 @@ fn aiur_fn_308(
         let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
         let __v_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_308] = [__v_8];
         record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -29886,7 +29604,7 @@ fn aiur_fn_308(
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __ret: [G; OUT_308] = [__v_5];
         record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -29911,32 +29629,25 @@ fn aiur_fn_309(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_309] = [__v_7];
-        record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __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_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_309] = [__v_8];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_309] = [__v_2];
         record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __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_5: G = __r_arr[0];
+        let __v_6: G = { let __values: [G; 2] = [__v_4, __v_5]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_309] = [__v_6];
+        record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -29954,20 +29665,16 @@ fn aiur_fn_310(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
         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_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 __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_310] = [__v_5];
+        let __v_2: G = __r_arr[0];
+        let __ret: [G; OUT_310] = [__v_2];
         record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -29987,7 +29694,7 @@ fn aiur_fn_311(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -29996,7 +29703,7 @@ fn aiur_fn_311(
       0u64 => {
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_311] = [__v_8];
         record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -30006,7 +29713,7 @@ fn aiur_fn_311(
         let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
         let __v_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_311] = [__v_9];
         record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -30016,7 +29723,7 @@ fn aiur_fn_311(
         let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_311] = [__v_9];
         record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -30028,7 +29735,7 @@ fn aiur_fn_311(
         let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __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 __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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_311] = [__v_10];
         record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -30040,7 +29747,7 @@ fn aiur_fn_311(
         let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __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 __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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_311] = [__v_10];
         record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -30052,7 +29759,7 @@ fn aiur_fn_311(
         let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __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 __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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_311] = [__v_10];
         record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -30065,7 +29772,7 @@ fn aiur_fn_311(
         let __v_8: G = __r_arr[0];
         let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __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 __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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_311] = [__v_10];
         record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -30073,7 +29780,7 @@ fn aiur_fn_311(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_311] = [__v_8];
         record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -30082,7 +29789,7 @@ fn aiur_fn_311(
         let __v_6: G = G::from_u64(8);
         let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __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 __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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_311] = [__v_8];
         record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -30106,94 +29813,75 @@ fn aiur_fn_312(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __v_22: G = G::from_u64(1);
-            let __ret: [G; OUT_312] = [__v_22];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_2: G = G::from_u64(1);
+            let __ret: [G; OUT_312] = [__v_2];
             record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_312] = [__v_22];
+            let __v_2: G = G::from_u64(0);
+            let __ret: [G; OUT_312] = [__v_2];
             record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_312] = [__v_22];
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_11: G = G::from_u64(0);
+            let __ret: [G; OUT_312] = [__v_11];
             record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            match __v_22.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+            let __v_11: G = __loaded[0];
+            let __v_12: G = __loaded[1];
+            let __v_13: G = __loaded[2];
+            let __v_14: G = __loaded[3];
+            let __v_15: G = __loaded[4];
+            let __v_16: G = __loaded[5];
+            let __v_17: G = __loaded[6];
+            let __v_18: G = __loaded[7];
+            let __v_19: G = __loaded[8];
+            let __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_20: G = __r_arr[0];
+            match __v_20.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_11, __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 __ret: [G; OUT_312] = [__v_23];
+                let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_10, __v_19]; 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_21: G = __r_arr[0];
+                let __ret: [G; OUT_312] = [__v_21];
                 record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_312] = [__v_23];
+                let __v_21: G = G::from_u64(0);
+                let __ret: [G; OUT_312] = [__v_21];
                 record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -30210,69 +29898,57 @@ fn aiur_fn_313(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_313] = [__v_8];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_2: G = G::from_u64(1);
+            let __ret: [G; OUT_313] = [__v_2];
             record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_313] = [__v_8];
+            let __v_2: G = G::from_u64(0);
+            let __ret: [G; OUT_313] = [__v_2];
             record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_313] = [__v_8];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_313] = [__v_4];
             record.function_queries[313].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() {
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_4: G = __loaded[0];
+            let __v_5: G = __loaded[1];
+            let __v_6: G = (__v_2 - __v_4);
+            match __v_6.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
-                let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_313] = [__v_9];
+                let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3, __v_5]; 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_7: G = __r_arr[0];
+                let __ret: [G; OUT_313] = [__v_7];
                 record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_313] = [__v_9];
+                let __v_7: G = G::from_u64(0);
+                let __ret: [G; OUT_313] = [__v_7];
                 record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -30344,7 +30020,7 @@ fn aiur_fn_315(
 ) -> Result<[G; OUT_315], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -30587,7 +30263,7 @@ fn aiur_fn_321(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -30798,7 +30474,7 @@ fn aiur_fn_324(
   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_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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
@@ -30832,7 +30508,7 @@ fn aiur_fn_325(
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_2]; 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_736] = { let __args: [G; IN_736] = [__v_0, __v_2]; 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_4: G = __r_arr[0];
         let __v_5: G = (__v_1 - __v_2);
         let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
@@ -30860,24 +30536,30 @@ fn aiur_fn_326(
 ) -> Result<[G; OUT_326], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
-        let __v_7: G = (__v_4 + __v_6);
-        let __ret: [G; OUT_326] = [__v_7];
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(1);
+        if (__v_1 != __v_2) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_326] = [__v_1];
         record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = G::from_u64(1);
+        let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__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_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_2, __v_4]; 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_5: G = __r_arr[0];
+        let __v_6: G = (__v_3 + __v_5);
+        let __ret: [G; OUT_326] = [__v_6];
+        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -30913,7 +30595,7 @@ fn aiur_fn_327(
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_2]; 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_736] = { let __args: [G; IN_736] = [__v_0, __v_2]; 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_4: G = __r_arr[0];
             let __v_5: G = (__v_1 - __v_2);
             let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_5]; 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)? } };
@@ -30946,15 +30628,13 @@ fn aiur_fn_328(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_328] = [__v_4];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_328] = [__v_2];
         record.function_queries[328].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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
         let __v_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() {
@@ -30964,13 +30644,13 @@ fn aiur_fn_328(
             return Ok(__ret);
           },
           1u64 => {
-            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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
             let __v_4: G = __r_arr[0];
             let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
             let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_6]; 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_7: G = __r_arr[0];
             let __ret: [G; OUT_328] = [__v_7];
             record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -31033,7 +30713,7 @@ fn aiur_fn_330(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -31242,7 +30922,7 @@ fn aiur_fn_334(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -31258,7 +30938,7 @@ fn aiur_fn_334(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_334] = [__v_9];
         record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31266,7 +30946,7 @@ fn aiur_fn_334(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_334] = [__v_9];
         record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31278,7 +30958,7 @@ fn aiur_fn_334(
         let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
         let __v_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_334] = [__v_11];
         record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31292,7 +30972,7 @@ fn aiur_fn_334(
         let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1, __v_10]; 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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_334] = [__v_13];
         record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31306,7 +30986,7 @@ fn aiur_fn_334(
         let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1, __v_10]; 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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_334] = [__v_13];
         record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31321,7 +31001,7 @@ fn aiur_fn_334(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_334] = [__v_9];
         record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31330,7 +31010,7 @@ fn aiur_fn_334(
         let __v_7: G = G::from_u64(8);
         let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
         let __v_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_334] = [__v_9];
         record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31360,7 +31040,7 @@ fn aiur_fn_335(
       1u64 => {
         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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_335] = [__v_6];
         record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31369,7 +31049,7 @@ fn aiur_fn_335(
         let __v_4: G = G::from_u64(0);
         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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_335] = [__v_7];
         record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31405,7 +31085,7 @@ fn aiur_fn_336(
     let __v_9: G = (__v_4 + __v_8);
     let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2, __v_3, __v_9]; 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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_336] = [__v_11];
     record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -31471,7 +31151,7 @@ fn aiur_fn_338(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -31489,7 +31169,7 @@ fn aiur_fn_338(
             let __v_8: G = G::from_u64(0);
             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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_338] = [__v_11];
             record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -31502,7 +31182,7 @@ fn aiur_fn_338(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_338] = [__v_9];
         record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31510,7 +31190,7 @@ fn aiur_fn_338(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_338] = [__v_9];
         record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31522,7 +31202,7 @@ fn aiur_fn_338(
         let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_5, __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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_338] = [__v_11];
         record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31536,7 +31216,7 @@ fn aiur_fn_338(
         let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_5, __v_1, __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 __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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_338] = [__v_13];
         record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31550,7 +31230,7 @@ fn aiur_fn_338(
         let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_5, __v_1, __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 __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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_338] = [__v_13];
         record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31565,7 +31245,7 @@ fn aiur_fn_338(
         let __v_11: G = (__v_2 + __v_10);
         let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __v_13: G = { 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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_338] = [__v_13];
         record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31573,7 +31253,7 @@ fn aiur_fn_338(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_338] = [__v_9];
         record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31582,7 +31262,7 @@ fn aiur_fn_338(
         let __v_7: G = G::from_u64(8);
         let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_338] = [__v_9];
         record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31644,7 +31324,7 @@ fn aiur_fn_340(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -31660,7 +31340,7 @@ fn aiur_fn_340(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_340] = [__v_9];
         record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31668,7 +31348,7 @@ fn aiur_fn_340(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_340] = [__v_9];
         record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31680,7 +31360,7 @@ fn aiur_fn_340(
         let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_1, __v_2]; 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 = 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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_340] = [__v_11];
         record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31694,7 +31374,7 @@ fn aiur_fn_340(
         let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_1, __v_10]; 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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_340] = [__v_13];
         record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31708,7 +31388,7 @@ fn aiur_fn_340(
         let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_1, __v_10]; 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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_340] = [__v_13];
         record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31723,7 +31403,7 @@ fn aiur_fn_340(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_340] = [__v_9];
         record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31732,7 +31412,7 @@ fn aiur_fn_340(
         let __v_7: G = G::from_u64(8);
         let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_6, __v_1, __v_2]; 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 = { 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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_340] = [__v_9];
         record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31763,7 +31443,7 @@ fn aiur_fn_341(
       1u64 => {
         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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_341] = [__v_6];
         record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31784,7 +31464,7 @@ fn aiur_fn_341(
             let __v_6: G = G::from_u64(1);
             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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_341] = [__v_9];
             record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -31822,7 +31502,7 @@ fn aiur_fn_342(
     let __v_9: G = (__v_4 + __v_8);
     let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_2, __v_3, __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 = { 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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_342] = [__v_11];
     record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -31879,14 +31559,14 @@ fn aiur_fn_344(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_1]; 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_734] = { let __args: [G; IN_734] = [__v_1]; 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_3: G = __r_arr[0];
     let __v_4: G = (__v_0 - __v_2);
     let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __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 __v_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_4]; 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_727] = { let __args: [G; IN_727] = [__v_1, __v_4]; 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_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
         let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_6, __v_2, __v_7]; 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)? } };
@@ -31899,7 +31579,7 @@ fn aiur_fn_344(
         let __v_6: G = G::from_u64(0);
         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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_344] = [__v_9];
         record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31924,7 +31604,7 @@ fn aiur_fn_345(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -31940,7 +31620,7 @@ fn aiur_fn_345(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_345] = [__v_9];
         record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31948,7 +31628,7 @@ fn aiur_fn_345(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_345] = [__v_9];
         record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31960,7 +31640,7 @@ fn aiur_fn_345(
         let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_1, __v_2]; 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_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 __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() + 1); __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));
         return Ok(__ret);
@@ -31974,7 +31654,7 @@ fn aiur_fn_345(
         let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_1, __v_10]; 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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_345] = [__v_13];
         record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -31988,7 +31668,7 @@ fn aiur_fn_345(
         let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_1, __v_10]; 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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_345] = [__v_13];
         record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -32003,7 +31683,7 @@ fn aiur_fn_345(
       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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_345] = [__v_9];
         record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -32012,7 +31692,7 @@ fn aiur_fn_345(
         let __v_7: G = G::from_u64(8);
         let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_1, __v_2]; 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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_345] = [__v_9];
         record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -32048,7 +31728,7 @@ fn aiur_fn_346(
     let __v_9: G = (__v_4 + __v_8);
     let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_2, __v_3, __v_9]; 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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_346] = [__v_11];
     record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -32068,36 +31748,31 @@ fn aiur_fn_347(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       4u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        match __v_7.as_canonical_u64() {
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_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_347] = { let __args: [G; IN_347] = [__v_5, __v_9, __v_11]; 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_12: G = __r_arr[0];
-            let __v_13: G = __r_arr[1];
-            let __v_14: G = __r_arr[2];
-            let __ret: [G; OUT_347] = [__v_12, __v_13, __v_14];
-            record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
             let __ret: [G; OUT_347] = [__v_0, __v_2, __v_1];
             record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = { let __values: [G; 2] = [__v_7, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_5, __v_8, __v_9]; 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 __v_12: G = __r_arr[2];
+            let __ret: [G; OUT_347] = [__v_10, __v_11, __v_12];
+            record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
@@ -32123,43 +31798,41 @@ fn aiur_fn_348(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __v_3: G = G::from_u64(1);
-    let __v_4: G = G::from_u64(1);
-    let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __v_0, __v_5]; 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_6: G = __r_arr[0];
-    let __v_7: G = __r_arr[1];
-    let __v_8: G = __r_arr[2];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_7]; 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_9: G = __r_arr[0];
-    match __v_9.as_canonical_u64() {
+    let __v_3: G = G::from_u64(0);
+    let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __v_0, __v_3]; 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_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    let __v_6: G = __r_arr[2];
+    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    match __v_7.as_canonical_u64() {
       0u64 => {
         let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_1, __v_0]; 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];
-        let __ret: [G; OUT_348] = [__v_10];
+        let __v_8: G = __r_arr[0];
+        let __ret: [G; OUT_348] = [__v_8];
         record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
+        let __v_8: G = G::from_u64(0);
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_7, __v_10]; 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_339] = { let __args: [G; IN_339] = [__v_4, __v_9, __v_10]; 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_11: G = __r_arr[0];
-        let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_6, __v_11, __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 __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_13, __v_8, __v_2]; 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_14: G = __r_arr[0];
-        let __ret: [G; OUT_348] = [__v_14];
+        let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_11, __v_6, __v_2]; 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_12: G = __r_arr[0];
+        let __ret: [G; OUT_348] = [__v_12];
         record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_7, __v_10]; 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_11, __v_8, __v_2]; 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_12: G = __r_arr[0];
-        let __ret: [G; OUT_348] = [__v_12];
+        let __v_8: G = G::from_u64(0);
+        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_5, __v_8]; 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_9: G = __r_arr[0];
+        let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_9, __v_6, __v_2]; 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_10: G = __r_arr[0];
+        let __ret: [G; OUT_348] = [__v_10];
         record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -32180,7 +31853,7 @@ fn aiur_fn_349(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -32190,7 +31863,7 @@ fn aiur_fn_349(
         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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_8, __v_1]; 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_725] = { let __args: [G; IN_725] = [__v_8, __v_1]; 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_9: G = __r_arr[0];
         let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_7, __v_9, __v_2]; 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_10: G = __r_arr[0];
@@ -32274,7 +31947,7 @@ fn aiur_fn_350(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_11: G = __loaded[0];
         let __v_12: G = __loaded[1];
         let __v_13: G = __loaded[2];
@@ -32283,7 +31956,7 @@ fn aiur_fn_350(
           2u64 => {
             let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_7]; 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_15: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_16: G = __loaded[0];
             let __v_17: G = __loaded[1];
             let __v_18: G = __loaded[2];
@@ -32299,7 +31972,7 @@ fn aiur_fn_350(
             match __v_16.as_canonical_u64() {
               6u64 => {
                 let __v_28: G = (__v_22 + __v_1);
-                let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_8, __v_28]; 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_727] = { let __args: [G; IN_727] = [__v_8, __v_28]; 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_29: G = __r_arr[0];
                 let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_29, __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 __v_30: G = __r_arr[0];
@@ -32309,7 +31982,7 @@ fn aiur_fn_350(
               },
               _ => {
                 let __v_28: G = G::from_u64(8);
-                let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_29, __v_3]; 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_30: G = __r_arr[0];
                 let __ret: [G; OUT_350] = [__v_30];
@@ -32320,7 +31993,7 @@ fn aiur_fn_350(
           },
           _ => {
             let __v_15: G = G::from_u64(8);
-            let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_3]; 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 __ret: [G; OUT_350] = [__v_17];
@@ -32375,7 +32048,7 @@ fn aiur_fn_351(
     let __v_29: G = G::from_u64(86);
     let __v_30: G = G::from_u64(91);
     let __v_31: G = G::from_u64(151);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_351] = [__v_32];
     record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -32424,7 +32097,7 @@ fn aiur_fn_352(
     let __v_29: G = G::from_u64(179);
     let __v_30: G = G::from_u64(87);
     let __v_31: G = G::from_u64(25);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_352] = [__v_32];
     record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -32473,7 +32146,7 @@ fn aiur_fn_353(
     let __v_29: G = G::from_u64(242);
     let __v_30: G = G::from_u64(182);
     let __v_31: G = G::from_u64(49);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_353] = [__v_32];
     record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -32522,7 +32195,7 @@ fn aiur_fn_354(
     let __v_29: G = G::from_u64(125);
     let __v_30: G = G::from_u64(236);
     let __v_31: G = G::from_u64(246);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_354] = [__v_32];
     record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -32571,7 +32244,7 @@ fn aiur_fn_355(
     let __v_29: G = G::from_u64(139);
     let __v_30: G = G::from_u64(123);
     let __v_31: G = G::from_u64(208);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_355] = [__v_32];
     record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -32620,7 +32293,7 @@ fn aiur_fn_356(
     let __v_29: G = G::from_u64(176);
     let __v_30: G = G::from_u64(173);
     let __v_31: G = G::from_u64(22);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_356] = [__v_32];
     record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -32651,7 +32324,7 @@ fn aiur_fn_357(
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_357] = [__v_6, __v_10];
         record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -32659,7 +32332,7 @@ fn aiur_fn_357(
       _ => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
@@ -32676,13 +32349,13 @@ fn aiur_fn_357(
                     let __v_13: G = G::from_u64(0);
                     let __v_14: G = G::from_u64(0);
                     let __v_15: G = G::from_u64(0);
-                    let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                     let __ret: [G; OUT_357] = [__v_12, __v_16];
                     record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_3]; 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_734] = { let __args: [G; IN_734] = [__v_3]; 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_12: G = __r_arr[0];
                     let __v_13: G = G::from_u64(5);
                     let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -32692,35 +32365,35 @@ fn aiur_fn_357(
                         let __v_16: G = G::from_u64(0);
                         let __v_17: G = G::from_u64(0);
                         let __v_18: G = G::from_u64(0);
-                        let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                         let __ret: [G; OUT_357] = [__v_15, __v_19];
                         record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_15: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_15]; 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_727] = { let __args: [G; IN_727] = [__v_3, __v_15]; 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_16: G = __r_arr[0];
                         let __v_17: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_17]; 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_727] = { let __args: [G; IN_727] = [__v_3, __v_17]; 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_18: G = __r_arr[0];
                         let __v_19: G = G::from_u64(2);
-                        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_19]; 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_727] = { let __args: [G; IN_727] = [__v_3, __v_19]; 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_20: G = __r_arr[0];
                         let __v_21: G = G::from_u64(3);
-                        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_21]; 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_727] = { let __args: [G; IN_727] = [__v_3, __v_21]; 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_22: G = __r_arr[0];
                         let __v_23: G = G::from_u64(4);
-                        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_23]; 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_727] = { let __args: [G; IN_727] = [__v_3, __v_23]; 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_24: G = __r_arr[0];
-                        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                         let __v_25: G = __loaded[0];
                         let __v_26: G = __loaded[1];
                         let __v_27: G = __loaded[2];
                         let __v_28: G = __loaded[3];
                         match __v_25.as_canonical_u64() {
                           4u64 => {
-                            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                            let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                             let __v_29: G = __loaded[0];
                             let __v_30: G = __loaded[1];
                             let __v_31: G = __loaded[2];
@@ -32728,11 +32401,11 @@ fn aiur_fn_357(
                             match __v_29.as_canonical_u64() {
                               4u64 => {
                                 let __v_33: G = G::from_u64(8);
-                                let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                 let __v_35: G = G::from_u64(4);
                                 let __v_36: G = G::from_u64(0);
-                                let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                                let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                                 let __v_38: G = __loaded[0];
                                 let __v_39: G = __loaded[1];
                                 let __v_40: G = __loaded[2];
@@ -32740,46 +32413,44 @@ fn aiur_fn_357(
                                 match __v_38.as_canonical_u64() {
                                   4u64 => {
                                     let __v_42: G = G::from_u64(8);
-                                    let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                     let __v_44: G = G::from_u64(4);
                                     let __v_45: G = G::from_u64(0);
-                                    let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                     let __v_47: G = G::from_u64(2);
                                     let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = []; 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_48: G = __r_arr[0];
-                                    let __v_49: G = G::from_u64(1);
-                                    let __v_50: G = G::from_u64(1);
-                                    let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __v_52: G = G::from_u64(0);
-                                    let __v_53: G = { let __values: [G; 4] = [__v_47, __v_48, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __v_54: G = G::from_u64(4);
-                                    let __v_55: G = G::from_u64(0);
-                                    let __v_56: G = { let __values: [G; 4] = [__v_54, __v_26, __v_53, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __v_57: G = G::from_u64(2);
-                                    let __v_58: G = G::from_u64(0);
-                                    let __v_59: G = { let __values: [G; 4] = [__v_57, __v_7, __v_8, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __v_60: G = G::from_u64(3);
-                                    let __v_61: G = G::from_u64(0);
-                                    let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_16, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __v_63: G = G::from_u64(3);
-                                    let __v_64: G = G::from_u64(0);
-                                    let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_56, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __v_66: G = G::from_u64(3);
-                                    let __v_67: G = G::from_u64(0);
-                                    let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_37, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __v_69: G = G::from_u64(3);
-                                    let __v_70: G = G::from_u64(0);
-                                    let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_46, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __v_72: G = G::from_u64(3);
-                                    let __v_73: G = G::from_u64(0);
-                                    let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __v_75: G = G::from_u64(5);
-                                    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_3, __v_75]; 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_49: G = G::from_u64(0);
+                                    let __v_50: G = G::from_u64(0);
+                                    let __v_51: G = { let __values: [G; 4] = [__v_47, __v_48, __v_49, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_52: G = G::from_u64(4);
+                                    let __v_53: G = G::from_u64(0);
+                                    let __v_54: G = { let __values: [G; 4] = [__v_52, __v_26, __v_51, __v_53]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_55: G = G::from_u64(2);
+                                    let __v_56: G = G::from_u64(0);
+                                    let __v_57: G = { let __values: [G; 4] = [__v_55, __v_7, __v_8, __v_56]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_58: G = G::from_u64(3);
+                                    let __v_59: G = G::from_u64(0);
+                                    let __v_60: G = { let __values: [G; 4] = [__v_58, __v_57, __v_16, __v_59]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_61: G = G::from_u64(3);
+                                    let __v_62: G = G::from_u64(0);
+                                    let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __v_54, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_64: G = G::from_u64(3);
+                                    let __v_65: G = G::from_u64(0);
+                                    let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_37, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_67: G = G::from_u64(3);
+                                    let __v_68: G = G::from_u64(0);
+                                    let __v_69: G = { let __values: [G; 4] = [__v_67, __v_66, __v_46, __v_68]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_70: G = G::from_u64(3);
+                                    let __v_71: G = G::from_u64(0);
+                                    let __v_72: G = { let __values: [G; 4] = [__v_70, __v_69, __v_24, __v_71]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_73: G = G::from_u64(5);
+                                    let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_3, __v_73]; 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_74: G = __r_arr[0];
+                                    let __v_75: G = G::from_u64(1);
+                                    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_72, __v_74]; 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_76: G = __r_arr[0];
-                                    let __v_77: G = G::from_u64(1);
-                                    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_74, __v_76]; 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_78: G = __r_arr[0];
-                                    let __ret: [G; OUT_357] = [__v_77, __v_78];
+                                    let __ret: [G; OUT_357] = [__v_75, __v_76];
                                     record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
@@ -32788,7 +32459,7 @@ fn aiur_fn_357(
                                     let __v_43: G = G::from_u64(0);
                                     let __v_44: G = G::from_u64(0);
                                     let __v_45: G = G::from_u64(0);
-                                    let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                     let __ret: [G; OUT_357] = [__v_42, __v_46];
                                     record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
@@ -32800,7 +32471,7 @@ fn aiur_fn_357(
                                 let __v_34: G = G::from_u64(0);
                                 let __v_35: G = G::from_u64(0);
                                 let __v_36: G = G::from_u64(0);
-                                let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                 let __ret: [G; OUT_357] = [__v_33, __v_37];
                                 record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
@@ -32812,7 +32483,7 @@ fn aiur_fn_357(
                             let __v_30: G = G::from_u64(0);
                             let __v_31: G = G::from_u64(0);
                             let __v_32: G = G::from_u64(0);
-                            let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                             let __ret: [G; OUT_357] = [__v_29, __v_33];
                             record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
@@ -32828,7 +32499,7 @@ fn aiur_fn_357(
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_357] = [__v_10, __v_14];
                 record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -32840,7 +32511,7 @@ fn aiur_fn_357(
             let __v_7: G = G::from_u64(0);
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(0);
-            let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_357] = [__v_6, __v_10];
             record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -32862,7 +32533,7 @@ fn aiur_fn_358(
 ) -> Result<[G; OUT_358], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -32881,12 +32552,12 @@ fn aiur_fn_358(
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_358] = [__v_15];
         record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -32907,33 +32578,26 @@ fn aiur_fn_359(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_359] = [__v_7];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_359] = [__v_2];
         record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_3, __v_1]; 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 __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_3, __v_1]; 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_5: G = __r_arr[0];
-        let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1]; 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_7: G = __r_arr[0];
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_359] = [__v_8];
+        let __v_6: G = { let __values: [G; 2] = [__v_4, __v_5]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_359] = [__v_6];
         record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -32953,7 +32617,7 @@ fn aiur_fn_360(
     let __v_2: G = inp[2];
     let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_3]; 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_734] = { let __args: [G; IN_734] = [__v_3]; 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_4: G = __r_arr[0];
     let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
@@ -32973,12 +32637,12 @@ fn aiur_fn_360(
         let __v_12: G = G::from_u64(0);
         let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         break '__mc_0 [__v_11, __v_15];
       },
       _ => {
         let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_3, __v_11]; 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_12: G = __r_arr[0];
         let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
@@ -32986,7 +32650,7 @@ fn aiur_fn_360(
         match __v_13.as_canonical_u64() {
           1u64 => {
             let __v_15: G = G::from_u64(1);
-            let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_3, __v_15]; 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_736] = { let __args: [G; IN_736] = [__v_3, __v_15]; 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_16: G = __r_arr[0];
             let __v_17: G = G::from_u64(1);
             let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_14]; 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)? } };
@@ -33002,7 +32666,7 @@ fn aiur_fn_360(
             let __v_16: G = G::from_u64(0);
             let __v_17: G = G::from_u64(0);
             let __v_18: G = G::from_u64(0);
-            let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             break '__mc_0 [__v_15, __v_19];
           },
         }
@@ -33020,12 +32684,12 @@ fn aiur_fn_360(
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             break '__mc_0 [__v_11, __v_15];
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_3, __v_11]; 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_12: G = __r_arr[0];
             let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
@@ -33033,7 +32697,7 @@ fn aiur_fn_360(
             match __v_13.as_canonical_u64() {
               1u64 => {
                 let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_3, __v_15]; 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_736] = { let __args: [G; IN_736] = [__v_3, __v_15]; 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_16: G = __r_arr[0];
                 let __v_17: G = G::from_u64(1);
                 let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__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)? } };
@@ -33051,7 +32715,7 @@ fn aiur_fn_360(
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
                 let __v_18: G = G::from_u64(0);
-                let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 break '__mc_0 [__v_15, __v_19];
               },
             }
@@ -33090,53 +32754,43 @@ fn aiur_fn_361(
     let __v_1: G = inp[1];
     let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
+    match __v_2.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_361] = [__v_2];
         record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        match __v_4.as_canonical_u64() {
+          0u64 => {
             let __ret: [G; OUT_361] = [__v_2];
             record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            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 __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_5: G = __loaded[0];
+            let __v_6: G = __loaded[1];
+            let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __v_8: G = __r_arr[1];
+            let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_10, __v_1]; 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_229] = { let __args: [G; IN_229] = [__v_7, __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];
+            let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_3, __v_1]; 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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_9, __v_11]; 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_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_1]; 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_13: G = __r_arr[0];
-            let __v_14: G = G::from_u64(0);
-            let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_361] = [__v_17];
+            let __v_12: G = { let __values: [G; 2] = [__v_10, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_13: G = { let __values: [G; 2] = [__v_11, __v_12]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_361] = [__v_13];
             record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -33477,7 +33131,7 @@ fn aiur_fn_363(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_363] = [__v_5, __v_9];
         record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -33531,7 +33185,7 @@ fn aiur_fn_364(
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(0);
             let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_364] = [__v_7, __v_11];
             record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -33554,7 +33208,7 @@ fn aiur_fn_365(
   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_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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(6);
     let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -33564,17 +33218,17 @@ fn aiur_fn_365(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_365] = [__v_5, __v_9];
         record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(3);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_5]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_5]; 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_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_7]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_7]; 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_8: G = __r_arr[0];
         let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } else { aiur_fn_367(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
@@ -33582,12 +33236,12 @@ fn aiur_fn_365(
         match __v_9.as_canonical_u64() {
           1u64 => {
             let __v_11: G = G::from_u64(6);
-            let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_11]; 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_736] = { let __args: [G; IN_736] = [__v_0, __v_11]; 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_12: G = __r_arr[0];
             let __v_13: G = G::from_u64(1);
             let __v_14: G = G::from_u64(3);
             let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __ret: [G; OUT_365] = [__v_13, __v_17];
@@ -33599,7 +33253,7 @@ fn aiur_fn_365(
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_365] = [__v_11, __v_15];
             record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -33622,7 +33276,7 @@ fn aiur_fn_366(
   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_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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(5);
     let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -33632,17 +33286,17 @@ fn aiur_fn_366(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_366] = [__v_5, __v_9];
         record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(3);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_5]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_5]; 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_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_7]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_7]; 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_8: G = __r_arr[0];
         let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } else { aiur_fn_367(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
@@ -33650,12 +33304,12 @@ fn aiur_fn_366(
         match __v_9.as_canonical_u64() {
           1u64 => {
             let __v_11: G = G::from_u64(5);
-            let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_11]; 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_736] = { let __args: [G; IN_736] = [__v_0, __v_11]; 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_12: G = __r_arr[0];
             let __v_13: G = G::from_u64(1);
             let __v_14: G = G::from_u64(3);
             let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __ret: [G; OUT_366] = [__v_13, __v_17];
@@ -33667,7 +33321,7 @@ fn aiur_fn_366(
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_366] = [__v_11, __v_15];
             record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -33695,7 +33349,7 @@ fn aiur_fn_367(
     let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -33708,7 +33362,7 @@ fn aiur_fn_367(
         let __v_10: G = __r_arr[0];
         match __v_10.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_4]; 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_734] = { let __args: [G; IN_734] = [__v_4]; 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_11: G = __r_arr[0];
             let __v_12: G = G::from_u64(3);
             let __v_13: G = (__v_11 - __v_12);
@@ -33716,7 +33370,7 @@ fn aiur_fn_367(
               0u64 => {
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = G::from_u64(2);
-                let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_15]; 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_727] = { let __args: [G; IN_727] = [__v_4, __v_15]; 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_16: G = __r_arr[0];
                 let __ret: [G; OUT_367] = [__v_14, __v_16];
                 record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -33727,7 +33381,7 @@ fn aiur_fn_367(
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_367] = [__v_14, __v_18];
                 record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -33739,7 +33393,7 @@ fn aiur_fn_367(
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_367] = [__v_11, __v_15];
             record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -33751,7 +33405,7 @@ fn aiur_fn_367(
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_367] = [__v_9, __v_13];
         record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -33794,7 +33448,7 @@ fn aiur_fn_368(
       _ => {
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -33974,7 +33628,7 @@ fn aiur_fn_369(
     let __v_7: G = __r_arr[4];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_1]; 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_734] = { let __args: [G; IN_734] = [__v_1]; 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_8: G = __r_arr[0];
         let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
         match __v_9.as_canonical_u64() {
@@ -33983,17 +33637,17 @@ fn aiur_fn_369(
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_369] = [__v_10, __v_14];
             record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_7]; 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_727] = { let __args: [G; IN_727] = [__v_1, __v_7]; 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 = G::from_u64(8);
-            let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_1, __v_4]; 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_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_1, __v_4]; 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_13: G = __r_arr[0];
             let __v_14: G = G::from_u64(1);
             let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_12, __v_13]; 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)? } };
@@ -34009,7 +33663,7 @@ fn aiur_fn_369(
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_369] = [__v_8, __v_12];
         record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -34030,7 +33684,7 @@ fn aiur_fn_370(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -34050,7 +33704,7 @@ fn aiur_fn_370(
         return Ok(__ret);
       },
       8u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -34103,7 +33757,7 @@ fn aiur_fn_370(
                 let __v_42: G = G::from_u64(0);
                 let __v_43: G = G::from_u64(0);
                 let __v_44: G = G::from_u64(0);
-                let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_46: G = G::from_u64(0);
                 let __v_47: G = G::from_u64(0);
                 let __ret: [G; OUT_370] = [__v_11, __v_12, __v_45, __v_46, __v_47];
@@ -34147,7 +33801,7 @@ fn aiur_fn_370(
             let __v_41: G = G::from_u64(0);
             let __v_42: G = G::from_u64(0);
             let __v_43: G = G::from_u64(0);
-            let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_45: G = G::from_u64(0);
             let __v_46: G = G::from_u64(0);
             let __ret: [G; OUT_370] = [__v_10, __v_11, __v_44, __v_45, __v_46];
@@ -34191,7 +33845,7 @@ fn aiur_fn_370(
         let __v_37: G = G::from_u64(0);
         let __v_38: G = G::from_u64(0);
         let __v_39: G = G::from_u64(0);
-        let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_41: G = G::from_u64(0);
         let __v_42: G = G::from_u64(0);
         let __ret: [G; OUT_370] = [__v_6, __v_7, __v_40, __v_41, __v_42];
@@ -34213,7 +33867,7 @@ fn aiur_fn_371(
 ) -> Result<[G; OUT_371], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -34229,12 +33883,10 @@ fn aiur_fn_371(
                 let __v_6: G = G::from_u64(2);
                 let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
-                let __v_8: G = G::from_u64(1);
-                let __v_9: G = G::from_u64(1);
-                let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_11: G = G::from_u64(0);
-                let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_371] = [__v_12];
+                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_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_371] = [__v_10];
                 record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -34246,19 +33898,17 @@ fn aiur_fn_371(
                 let __v_8: G = G::from_u64(7);
                 let __v_9: G = G::from_u64(0);
                 let __v_10: G = G::from_u64(0);
-                let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_12: G = G::from_u64(2);
                 let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
-                let __v_14: G = G::from_u64(1);
-                let __v_15: G = G::from_u64(1);
-                let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_17: G = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_19: G = G::from_u64(3);
-                let __v_20: G = G::from_u64(0);
-                let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_371] = [__v_21];
+                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_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_17: G = G::from_u64(3);
+                let __v_18: G = G::from_u64(0);
+                let __v_19: G = { let __values: [G; 4] = [__v_17, __v_16, __v_11, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_371] = [__v_19];
                 record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -34299,69 +33949,78 @@ fn aiur_fn_372(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-    let __v_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    let __v_12: G = __loaded[3];
-    let __v_13: G = __loaded[4];
-    match __v_9.as_canonical_u64() {
+    match __v_6.as_canonical_u64() {
       0u64 => {
-        match __v_10.as_canonical_u64() {
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = G::from_u64(0);
+        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_372] = [__v_9, __v_13];
+        record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_9: G = __loaded[0];
+        let __v_10: G = __loaded[1];
+        let __v_11: G = __loaded[2];
+        let __v_12: G = __loaded[3];
+        match __v_9.as_canonical_u64() {
           _ => {
-            let __v_14: G = (__v_4 + __v_5);
-            let __v_15: G = (__v_3 + __v_14);
-            let __v_16: G = (__v_2 + __v_15);
-            let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_1]; 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_13: G = (__v_4 + __v_5);
+            let __v_14: G = (__v_3 + __v_13);
+            let __v_15: G = (__v_2 + __v_14);
+            let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_1]; 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_16: G = __r_arr[0];
+            let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
-            let __v_18: G = __r_arr[0];
-            match __v_18.as_canonical_u64() {
+            match __v_17.as_canonical_u64() {
               0u64 => {
+                let __v_18: G = G::from_u64(0);
                 let __v_19: G = G::from_u64(0);
                 let __v_20: G = G::from_u64(0);
                 let __v_21: G = G::from_u64(0);
-                let __v_22: G = G::from_u64(0);
-                let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_372] = [__v_19, __v_23];
+                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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_372] = [__v_18, __v_22];
                 record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_16]; 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_727] = { let __args: [G; IN_727] = [__v_1, __v_15]; 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_18: G = __r_arr[0];
+                let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_18, __v_9, __v_2, __v_7, __v_8]; 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_19: G = __r_arr[0];
-                let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } };
-                let __v_20: G = __r_arr[0];
-                match __v_20.as_canonical_u64() {
+                match __v_19.as_canonical_u64() {
                   0u64 => {
+                    let __v_20: G = G::from_u64(0);
                     let __v_21: G = G::from_u64(0);
                     let __v_22: G = G::from_u64(0);
                     let __v_23: G = G::from_u64(0);
-                    let __v_24: G = G::from_u64(0);
-                    let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_372] = [__v_21, __v_25];
+                    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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __ret: [G; OUT_372] = [__v_20, __v_24];
                     record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_12, __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 __v_21: G = __r_arr[0];
-                    let __v_22: G = (__v_3 + __v_4);
-                    let __v_23: G = (__v_2 + __v_22);
-                    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_1, __v_23]; 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_24: G = __r_arr[0];
-                    let __v_25: G = G::from_u64(1);
-                    let __v_26: G = (__v_16 + __v_25);
-                    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_1, __v_26]; 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_310] = { let __args: [G; IN_310] = [__v_11, __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 __v_20: G = __r_arr[0];
+                    let __v_21: G = (__v_3 + __v_4);
+                    let __v_22: G = (__v_2 + __v_21);
+                    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_1, __v_22]; 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_23: G = __r_arr[0];
+                    let __v_24: G = G::from_u64(1);
+                    let __v_25: G = (__v_15 + __v_24);
+                    let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_1, __v_25]; 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_26: G = __r_arr[0];
+                    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_20, __v_23]; 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];
-                    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_27, __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_28: G = __r_arr[0];
-                    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_28, __v_27]; 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_29: G = __r_arr[0];
-                    let __v_30: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_29, __v_8]; 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_31: G = __r_arr[0];
-                    let __ret: [G; OUT_372] = [__v_30, __v_31];
+                    let __v_29: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_28, __v_8]; 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_30: G = __r_arr[0];
+                    let __ret: [G; OUT_372] = [__v_29, __v_30];
                     record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
@@ -34371,16 +34030,6 @@ fn aiur_fn_372(
           },
         }
       },
-      _ => {
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = G::from_u64(0);
-        let __v_16: G = G::from_u64(0);
-        let __v_17: G = G::from_u64(0);
-        let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_372] = [__v_14, __v_18];
-        record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
     }
   })
 }
@@ -34407,7 +34056,7 @@ fn aiur_fn_373(
     let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_6]; 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_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_9: G = __loaded[0];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
@@ -34426,7 +34075,7 @@ fn aiur_fn_373(
           _ => {
             let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_15: G = __loaded[0];
             let __v_16: G = __loaded[1];
             let __v_17: G = __loaded[2];
@@ -34445,8 +34094,8 @@ fn aiur_fn_373(
                 let __v_27: G = __r_arr[0];
                 let __v_28: G = G::from_u64(2);
                 let __v_29: G = G::from_u64(0);
-                let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_8, __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 __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_8, __v_2]; 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_31: G = __r_arr[0];
                 let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_30, __v_31]; 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_32: G = __r_arr[0];
@@ -34491,22 +34140,19 @@ fn aiur_fn_374(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0, __v_1]; 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_735] = { let __args: [G; IN_735] = [__v_0, __v_1]; 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_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(1);
     let __v_5: G = (__v_1 + __v_4);
-    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __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_736] = { let __args: [G; IN_736] = [__v_0, __v_5]; 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_6: G = __r_arr[0];
     let __v_7: G = G::from_u64(0);
-    let __v_8: G = G::from_u64(1);
-    let __v_9: G = G::from_u64(1);
-    let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_3, __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_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_6]; 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_13: G = __r_arr[0];
-    let __ret: [G; OUT_374] = [__v_13];
+    let __v_8: G = { let __values: [G; 2] = [__v_2, __v_7]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_9, __v_6]; 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_10: G = __r_arr[0];
+    let __ret: [G; OUT_374] = [__v_10];
     record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -34529,7 +34175,7 @@ fn aiur_fn_375(
     let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -34538,7 +34184,7 @@ fn aiur_fn_375(
       2u64 => {
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
@@ -34602,7 +34248,7 @@ fn aiur_fn_376(
     let __v_10: G = (__v_4 + __v_5);
     let __v_11: G = (__v_3 + __v_10);
     let __v_12: G = (__v_2 + __v_11);
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_1]; 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_734] = { let __args: [G; IN_734] = [__v_1]; 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_13: G = __r_arr[0];
     let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
     match __v_14.as_canonical_u64() {
@@ -34611,7 +34257,7 @@ fn aiur_fn_376(
         let __v_16: G = G::from_u64(0);
         let __v_17: G = G::from_u64(0);
         let __v_18: G = G::from_u64(0);
-        let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_376] = [__v_15, __v_19];
         record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -34628,7 +34274,7 @@ fn aiur_fn_376(
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_12]; 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_727] = { let __args: [G; IN_727] = [__v_1, __v_12]; 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_17: G = __r_arr[0];
             let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__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 __v_18: G = __r_arr[0];
@@ -34671,16 +34317,16 @@ fn aiur_fn_376(
                     let __v_31: G = __r_arr[0];
                     let __v_32: G = (__v_3 + __v_4);
                     let __v_33: G = (__v_2 + __v_32);
-                    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_1, __v_33]; 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_735] = { let __args: [G; IN_735] = [__v_1, __v_33]; 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_34: G = __r_arr[0];
-                    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_25]; 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_734] = { let __args: [G; IN_734] = [__v_25]; 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_35: G = __r_arr[0];
                     let __v_36: G = (__v_35 - __v_27);
-                    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_25, __v_36]; 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_37: G = __r_arr[0];
                     let __v_38: G = G::from_u64(1);
                     let __v_39: G = (__v_12 + __v_38);
-                    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_1, __v_39]; 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_736] = { let __args: [G; IN_736] = [__v_1, __v_39]; 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_40: G = __r_arr[0];
                     let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_31, __v_34]; 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_41: G = __r_arr[0];
@@ -34730,7 +34376,7 @@ fn aiur_fn_377(
     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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -34739,7 +34385,7 @@ fn aiur_fn_377(
       2u64 => {
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -34796,11 +34442,9 @@ fn aiur_fn_377(
             let __v_51: G = G::from_u64(0);
             let __v_52: G = G::from_u64(0);
             let __v_53: G = G::from_u64(0);
-            let __v_54: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_55: G = G::from_u64(1);
-            let __v_56: G = G::from_u64(1);
-            let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_377] = [__v_20, __v_21, __v_54, __v_57];
+            let __v_54: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_55: G = G::from_u64(0);
+            let __ret: [G; OUT_377] = [__v_20, __v_21, __v_54, __v_55];
             record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -34841,11 +34485,9 @@ fn aiur_fn_377(
         let __v_38: G = G::from_u64(0);
         let __v_39: G = G::from_u64(0);
         let __v_40: G = G::from_u64(0);
-        let __v_41: G = { let __values: [G; 32] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_42: G = G::from_u64(1);
-        let __v_43: G = G::from_u64(1);
-        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_377] = [__v_7, __v_8, __v_41, __v_44];
+        let __v_41: G = { let __values: [G; 32] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_42: G = G::from_u64(0);
+        let __ret: [G; OUT_377] = [__v_7, __v_8, __v_41, __v_42];
         record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -34865,41 +34507,40 @@ fn aiur_fn_378(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_378] = [__v_7, __v_8, __v_12];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = { 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_378] = [__v_2, __v_3, __v_7];
         record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_3.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        match __v_2.as_canonical_u64() {
           _ => {
-            let __v_7: G = (__v_3 - __v_1);
-            match __v_7.as_canonical_u64() {
+            let __v_6: G = (__v_2 - __v_1);
+            match __v_6.as_canonical_u64() {
               0u64 => {
-                let __v_8: G = G::from_u64(1);
-                let __ret: [G; OUT_378] = [__v_8, __v_4, __v_5];
+                let __v_7: G = G::from_u64(1);
+                let __ret: [G; OUT_378] = [__v_7, __v_3, __v_4];
                 record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } };
-                let __v_8: G = __r_arr[0];
-                let __v_9: G = __r_arr[1];
-                let __v_10: G = __r_arr[2];
-                let __ret: [G; OUT_378] = [__v_8, __v_9, __v_10];
+                let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } };
+                let __v_7: G = __r_arr[0];
+                let __v_8: G = __r_arr[1];
+                let __v_9: G = __r_arr[2];
+                let __ret: [G; OUT_378] = [__v_7, __v_8, __v_9];
                 record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -34907,9 +34548,6 @@ fn aiur_fn_378(
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -34933,136 +34571,119 @@ fn aiur_fn_379(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-    let __v_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    let __v_12: G = __loaded[3];
-    let __v_13: G = __loaded[4];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = G::from_u64(0);
-        let __v_16: G = G::from_u64(0);
-        let __v_17: G = G::from_u64(0);
-        let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_379] = [__v_14, __v_18];
+    match __v_7.as_canonical_u64() {
+      0u64 => {
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = G::from_u64(0);
+        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_379] = [__v_9, __v_13];
         record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-        let __v_14: G = __loaded[0];
-        let __v_15: G = __loaded[1];
-        let __v_16: G = __loaded[2];
-        let __v_17: G = __loaded[3];
-        let __v_18: G = __loaded[4];
-        match __v_14.as_canonical_u64() {
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_9: G = __loaded[0];
+        let __v_10: G = __loaded[1];
+        let __v_11: G = __loaded[2];
+        let __v_12: G = __loaded[3];
+        match __v_12.as_canonical_u64() {
           0u64 => {
-            let __v_19: G = G::from_u64(0);
-            let __v_20: G = G::from_u64(0);
-            let __v_21: G = G::from_u64(0);
-            let __v_22: G = G::from_u64(0);
-            let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_379] = [__v_19, __v_23];
-            record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            match __v_10.as_canonical_u64() {
+            match __v_9.as_canonical_u64() {
               _ => {
-                let __v_19: G = (__v_3 + __v_4);
-                let __v_20: G = (__v_19 + __v_5);
-                let __v_21: G = (__v_20 + __v_6);
-                let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_21]; 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_22: G = __r_arr[0];
-                let __v_23: G = __r_arr[1];
-                match __v_22.as_canonical_u64() {
+                let __v_13: G = (__v_3 + __v_4);
+                let __v_14: G = (__v_13 + __v_5);
+                let __v_15: G = (__v_14 + __v_6);
+                let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_15]; 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_16: G = __r_arr[0];
+                let __v_17: G = __r_arr[1];
+                match __v_16.as_canonical_u64() {
                   0u64 => {
-                    let __v_24: G = G::from_u64(0);
-                    let __v_25: G = G::from_u64(0);
-                    let __v_26: G = G::from_u64(0);
-                    let __v_27: G = G::from_u64(0);
-                    let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_379] = [__v_24, __v_28];
+                    let __v_18: G = G::from_u64(0);
+                    let __v_19: G = G::from_u64(0);
+                    let __v_20: G = G::from_u64(0);
+                    let __v_21: G = G::from_u64(0);
+                    let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __ret: [G; OUT_379] = [__v_18, __v_22];
                     record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
-                    let __v_24: G = __r_arr[0];
-                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-                    let __v_25: G = __loaded[0];
-                    let __v_26: G = __loaded[1];
-                    let __v_27: G = __loaded[2];
-                    let __v_28: G = __loaded[3];
-                    let __v_29: G = __loaded[4];
-                    let __v_30: G = __loaded[5];
-                    let __v_31: G = __loaded[6];
-                    let __v_32: G = __loaded[7];
-                    let __v_33: G = __loaded[8];
-                    let __v_34: G = __loaded[9];
-                    let __v_35: G = __loaded[10];
-                    let __v_36: G = __loaded[11];
-                    match __v_25.as_canonical_u64() {
+                    let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_17]; 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_18: G = __r_arr[0];
+                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                    let __v_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];
+                    match __v_19.as_canonical_u64() {
                       5u64 => {
-                        let __v_37: G = G::from_u64(1);
-                        let __v_38: G = (__v_30 - __v_37);
-                        match __v_38.as_canonical_u64() {
+                        let __v_31: G = G::from_u64(1);
+                        let __v_32: G = (__v_24 - __v_31);
+                        match __v_32.as_canonical_u64() {
                           0u64 => {
-                            match __v_29.as_canonical_u64() {
+                            match __v_23.as_canonical_u64() {
                               0u64 => {
-                                let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_23]; 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_39: G = __r_arr[0];
-                                match __v_39.as_canonical_u64() {
+                                let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_17]; 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_33: G = __r_arr[0];
+                                match __v_33.as_canonical_u64() {
                                   1u64 => {
-                                    let __v_40: G = G::from_u64(0);
-                                    let __v_41: G = G::from_u64(0);
-                                    let __v_42: G = G::from_u64(0);
-                                    let __v_43: G = G::from_u64(0);
-                                    let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __ret: [G; OUT_379] = [__v_40, __v_44];
+                                    let __v_34: G = G::from_u64(0);
+                                    let __v_35: G = G::from_u64(0);
+                                    let __v_36: G = G::from_u64(0);
+                                    let __v_37: G = G::from_u64(0);
+                                    let __v_38: G = { let __values: [G; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __ret: [G; OUT_379] = [__v_34, __v_38];
                                     record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
-                                    let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_21]; 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_40: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_40, __v_8]; 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_41: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_41, __v_8]; 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_42: G = __r_arr[0];
-                                    match __v_42.as_canonical_u64() {
+                                    let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_2, __v_15]; 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_34: G = __r_arr[0];
+                                    let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_34, __v_8]; 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_35: G = __r_arr[0];
+                                    let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_35, __v_8]; 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_36: G = __r_arr[0];
+                                    match __v_36.as_canonical_u64() {
                                       1u64 => {
-                                        let __v_43: G = G::from_u64(0);
-                                        let __v_44: G = G::from_u64(0);
-                                        let __v_45: G = G::from_u64(0);
-                                        let __v_46: G = G::from_u64(0);
-                                        let __v_47: G = { let __values: [G; 4] = [__v_44, __v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_379] = [__v_43, __v_47];
+                                        let __v_37: G = G::from_u64(0);
+                                        let __v_38: G = G::from_u64(0);
+                                        let __v_39: G = G::from_u64(0);
+                                        let __v_40: G = G::from_u64(0);
+                                        let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __ret: [G; OUT_379] = [__v_37, __v_41];
                                         record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_12, __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_310] = { let __args: [G; IN_310] = [__v_11, __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 __v_37: G = __r_arr[0];
+                                        let __v_38: G = (__v_3 + __v_4);
+                                        let __v_39: G = (__v_38 + __v_5);
+                                        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2, __v_39]; 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_40: G = __r_arr[0];
+                                        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_37, __v_40]; 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_41: G = __r_arr[0];
+                                        let __v_42: G = G::from_u64(0);
+                                        let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_41, __v_17, __v_34, __v_10, __v_42]; 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_43: G = __r_arr[0];
-                                        let __v_44: G = (__v_3 + __v_4);
-                                        let __v_45: G = (__v_44 + __v_5);
-                                        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_2, __v_45]; 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_44: G = G::from_u64(1);
+                                        let __v_45: G = (__v_15 + __v_44);
+                                        let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_2, __v_45]; 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_46: G = __r_arr[0];
+                                        let __v_47: G = G::from_u64(1);
                                         let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_43, __v_46]; 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_47: G = __r_arr[0];
-                                        let __v_48: G = G::from_u64(0);
-                                        let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_47, __v_23, __v_40, __v_11, __v_48]; 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_49: G = __r_arr[0];
-                                        let __v_50: G = G::from_u64(1);
-                                        let __v_51: G = (__v_21 + __v_50);
-                                        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2, __v_51]; 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_52: G = __r_arr[0];
-                                        let __v_53: G = G::from_u64(1);
-                                        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_49, __v_52]; 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 __ret: [G; OUT_379] = [__v_53, __v_54];
+                                        let __v_48: G = __r_arr[0];
+                                        let __ret: [G; OUT_379] = [__v_47, __v_48];
                                         record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
@@ -35071,36 +34692,36 @@ fn aiur_fn_379(
                                 }
                               },
                               _ => {
-                                let __v_39: G = G::from_u64(0);
-                                let __v_40: G = G::from_u64(0);
-                                let __v_41: G = G::from_u64(0);
-                                let __v_42: G = G::from_u64(0);
-                                let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_379] = [__v_39, __v_43];
+                                let __v_33: G = G::from_u64(0);
+                                let __v_34: G = G::from_u64(0);
+                                let __v_35: G = G::from_u64(0);
+                                let __v_36: G = G::from_u64(0);
+                                let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __ret: [G; OUT_379] = [__v_33, __v_37];
                                 record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
-                            let __v_39: G = G::from_u64(0);
-                            let __v_40: G = G::from_u64(0);
-                            let __v_41: G = G::from_u64(0);
-                            let __v_42: G = G::from_u64(0);
-                            let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_379] = [__v_39, __v_43];
+                            let __v_33: G = G::from_u64(0);
+                            let __v_34: G = G::from_u64(0);
+                            let __v_35: G = G::from_u64(0);
+                            let __v_36: G = G::from_u64(0);
+                            let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __ret: [G; OUT_379] = [__v_33, __v_37];
                             record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        let __v_37: G = G::from_u64(0);
-                        let __v_38: G = G::from_u64(0);
-                        let __v_39: G = G::from_u64(0);
-                        let __v_40: G = G::from_u64(0);
-                        let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_379] = [__v_37, __v_41];
+                        let __v_31: G = G::from_u64(0);
+                        let __v_32: G = G::from_u64(0);
+                        let __v_33: G = G::from_u64(0);
+                        let __v_34: G = G::from_u64(0);
+                        let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __ret: [G; OUT_379] = [__v_31, __v_35];
                         record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
@@ -35111,13 +34732,17 @@ fn aiur_fn_379(
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = G::from_u64(0);
+            let __v_15: G = G::from_u64(0);
+            let __v_16: G = G::from_u64(0);
+            let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_379] = [__v_13, __v_17];
+            record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-      },
     }
   })
 }
@@ -35136,7 +34761,7 @@ fn aiur_fn_380(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
@@ -35146,7 +34771,7 @@ fn aiur_fn_380(
             let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             let __v_7: G = __r_arr[1];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_8: G = __loaded[0];
             let __v_9: G = __loaded[1];
             let __v_10: G = __loaded[2];
@@ -35192,7 +34817,7 @@ fn aiur_fn_380(
                 let __v_42: G = G::from_u64(0);
                 let __v_43: G = G::from_u64(0);
                 let __v_44: G = G::from_u64(0);
-                let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_380] = [__v_12, __v_45];
                 record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -35233,7 +34858,7 @@ fn aiur_fn_380(
             let __v_36: G = G::from_u64(0);
             let __v_37: G = G::from_u64(0);
             let __v_38: G = G::from_u64(0);
-            let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_380] = [__v_6, __v_39];
             record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -35241,7 +34866,7 @@ fn aiur_fn_380(
         }
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
@@ -35291,7 +34916,7 @@ fn aiur_fn_380(
             let __v_36: G = G::from_u64(0);
             let __v_37: G = G::from_u64(0);
             let __v_38: G = G::from_u64(0);
-            let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_380] = [__v_6, __v_39];
             record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -35326,10 +34951,10 @@ fn aiur_fn_381(
       },
       _ => {
         let __v_6: G = G::from_u64(8);
-        let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_8: G = G::from_u64(3);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __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_381] = { let __args: [G; IN_381] = [__v_10, __v_1, __v_2, __v_3, __v_12]; 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)? } };
@@ -35355,7 +34980,7 @@ fn aiur_fn_382(
     let __v_0: G = inp[0];
     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; 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_1: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -35462,11 +35087,8 @@ fn aiur_fn_383(
           },
           _ => {
             let __v_50: G = G::from_u64(0);
-            let __v_51: G = G::from_u64(1);
-            let __v_52: G = G::from_u64(1);
-            let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_383] = [__v_54];
+            let __v_51: G = { let __values: [G; 2] = [__v_0, __v_50]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_383] = [__v_51];
             record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -35503,7 +35125,7 @@ fn aiur_fn_384(
       _ => {
         let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_1, __v_5]; 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_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -35571,7 +35193,7 @@ fn aiur_fn_385(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
@@ -35609,7 +35231,7 @@ fn aiur_fn_386(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -35656,7 +35278,7 @@ fn aiur_fn_387(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -35786,39 +35408,35 @@ fn aiur_fn_388(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_388] = [__v_5];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_388] = [__v_2];
         record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        match __v_5.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        match __v_4.as_canonical_u64() {
           1u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_388] = [__v_6];
+            let __v_5: G = G::from_u64(1);
+            let __ret: [G; OUT_388] = [__v_5];
             record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __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_6: G = __r_arr[0];
-            let __ret: [G; OUT_388] = [__v_6];
+            let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __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 __v_5: G = __r_arr[0];
+            let __ret: [G; OUT_388] = [__v_5];
             record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -35835,7 +35453,7 @@ fn aiur_fn_389(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -35871,12 +35489,10 @@ fn aiur_fn_389(
         let __v_6: G = __r_arr[0];
         let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0, __v_10, __v_7]; 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_11: G = __r_arr[0];
-        let __ret: [G; OUT_389] = [__v_11];
+        let __v_8: G = G::from_u64(0);
+        let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0, __v_8, __v_7]; 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_9: G = __r_arr[0];
+        let __ret: [G; OUT_389] = [__v_9];
         record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -35896,12 +35512,10 @@ fn aiur_fn_390(
   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_349] = { let __args: [G; IN_349] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __ret: [G; OUT_390] = [__v_5];
+    let __v_2: G = G::from_u64(0);
+    let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0, __v_2, __v_1]; 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_3: G = __r_arr[0];
+    let __ret: [G; OUT_390] = [__v_3];
     record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -35919,7 +35533,7 @@ fn aiur_fn_391(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -35955,12 +35569,10 @@ fn aiur_fn_391(
         let __v_6: G = __r_arr[0];
         let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_391] = [__v_11];
+        let __v_8: G = G::from_u64(0);
+        let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __ret: [G; OUT_391] = [__v_9];
         record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -35980,12 +35592,10 @@ fn aiur_fn_392(
   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_393] = { let __args: [G; IN_393] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __ret: [G; OUT_392] = [__v_5];
+    let __v_2: G = G::from_u64(0);
+    let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_2, __v_1]; 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_3: G = __r_arr[0];
+    let __ret: [G; OUT_392] = [__v_3];
     record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -36004,7 +35614,7 @@ fn aiur_fn_393(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -36014,7 +35624,7 @@ fn aiur_fn_393(
         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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_8, __v_1]; 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_725] = { let __args: [G; IN_725] = [__v_8, __v_1]; 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_9: G = __r_arr[0];
         let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_7, __v_9, __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_10: G = __r_arr[0];
@@ -36077,43 +35687,41 @@ fn aiur_fn_394(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __v_3: G = G::from_u64(1);
-    let __v_4: G = G::from_u64(1);
-    let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __v_0, __v_5]; 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_6: G = __r_arr[0];
-    let __v_7: G = __r_arr[1];
-    let __v_8: G = __r_arr[2];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_7]; 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_9: G = __r_arr[0];
-    match __v_9.as_canonical_u64() {
+    let __v_3: G = G::from_u64(0);
+    let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __v_0, __v_3]; 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_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    let __v_6: G = __r_arr[2];
+    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    match __v_7.as_canonical_u64() {
       0u64 => {
         let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_1, __v_0]; 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];
-        let __ret: [G; OUT_394] = [__v_10];
+        let __v_8: G = __r_arr[0];
+        let __ret: [G; OUT_394] = [__v_8];
         record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
+        let __v_8: G = G::from_u64(0);
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_7, __v_10]; 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_339] = { let __args: [G; IN_339] = [__v_4, __v_9, __v_10]; 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_11: G = __r_arr[0];
-        let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_6, __v_11, __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 __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_13, __v_8, __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_14: G = __r_arr[0];
-        let __ret: [G; OUT_394] = [__v_14];
+        let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_11, __v_6, __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_12: G = __r_arr[0];
+        let __ret: [G; OUT_394] = [__v_12];
         record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_7, __v_10]; 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_11, __v_8, __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_12: G = __r_arr[0];
-        let __ret: [G; OUT_394] = [__v_12];
+        let __v_8: G = G::from_u64(0);
+        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_5, __v_8]; 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_9: G = __r_arr[0];
+        let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_9, __v_6, __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_10: G = __r_arr[0];
+        let __ret: [G; OUT_394] = [__v_10];
         record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -36155,7 +35763,7 @@ fn aiur_fn_395(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_11: G = __loaded[0];
         let __v_12: G = __loaded[1];
         let __v_13: G = __loaded[2];
@@ -36164,7 +35772,7 @@ fn aiur_fn_395(
           2u64 => {
             let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_7]; 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_15: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_16: G = __loaded[0];
             let __v_17: G = __loaded[1];
             let __v_18: G = __loaded[2];
@@ -36180,7 +35788,7 @@ fn aiur_fn_395(
             match __v_16.as_canonical_u64() {
               6u64 => {
                 let __v_28: G = (__v_22 + __v_1);
-                let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_8, __v_28]; 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_727] = { let __args: [G; IN_727] = [__v_8, __v_28]; 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_29: G = __r_arr[0];
                 let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } };
                 let __v_30: G = __r_arr[0];
@@ -36190,7 +35798,7 @@ fn aiur_fn_395(
               },
               _ => {
                 let __v_28: G = G::from_u64(8);
-                let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_29, __v_3]; 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_30: G = __r_arr[0];
                 let __ret: [G; OUT_395] = [__v_30];
@@ -36201,7 +35809,7 @@ fn aiur_fn_395(
           },
           _ => {
             let __v_15: G = G::from_u64(8);
-            let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16, __v_3]; 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 __ret: [G; OUT_395] = [__v_17];
@@ -36248,7 +35856,7 @@ fn aiur_fn_396(
       _ => {
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -36352,7 +35960,7 @@ fn aiur_fn_397(
   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_726] = { let __args: [G; IN_726] = [__v_0, __v_1]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(1);
     let __v_4: G = (__v_1 + __v_3);
@@ -36521,14 +36129,14 @@ fn aiur_fn_400(
     let __v_2: G = __r_arr[0];
     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_3: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
     let __v_7: G = __loaded[3];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() {
   0u64 => {
-    let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_5]; 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_727] = { let __args: [G; IN_727] = [__v_3, __v_5]; 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_8: G = __r_arr[0];
     let __v_9: G = G::from_u64(1);
     let __v_10: G = (__v_5 + __v_9);
@@ -36541,17 +36149,17 @@ fn aiur_fn_400(
     let __v_8: G = G::from_u64(1);
     let __v_9: G = G::from_u64(1);
     let __v_10: G = G::from_u64(0);
-    let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_11]; 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_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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     break '__mc_0 [__v_14];
   },
   2u64 => {
     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_9: G = __loaded[0];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
@@ -36568,7 +36176,7 @@ fn aiur_fn_400(
     let __v_21: G = __r_arr[0];
     let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_9, __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[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_22: G = __r_arr[0];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
     let __v_23: G = __r_arr[0];
     if (__v_23 != __v_21) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
@@ -36580,7 +36188,7 @@ fn aiur_fn_400(
   3u64 => {
     let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
     let __v_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_9: G = __loaded[0];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
@@ -36595,7 +36203,7 @@ fn aiur_fn_400(
       _ => {
         let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_14: G = __loaded[0];
         let __v_15: G = __loaded[1];
         let __v_16: G = __loaded[2];
@@ -36615,28 +36223,26 @@ fn aiur_fn_400(
     }
   },
   4u64 => {
-    let __v_8: G = G::from_u64(0);
-    let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_6, __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 = 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 } };
-    break '__mc_0 [__v_13];
+    let __v_8: G = { let __values: [G; 2] = [__v_5, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_6, __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 __v_10: G = G::from_u64(5);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = { let __values: [G; 4] = [__v_10, __v_5, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    break '__mc_0 [__v_12];
   },
   5u64 => {
     let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __v_3]; 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_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_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_402] = { let __args: [G; IN_402] = [__v_6, __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 __v_11: G = __r_arr[0];
-    let __v_12: G = G::from_u64(1);
-    let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_8, __v_11]; 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_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 } };
-    break '__mc_0 [__v_15];
+    let __v_9: G = { let __values: [G; 2] = [__v_5, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_6, __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 __v_10: G = __r_arr[0];
+    let __v_11: G = G::from_u64(1);
+    let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_8, __v_10]; 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_12: G = __r_arr[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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    break '__mc_0 [__v_14];
   },
   6u64 => {
     let __v_8: G = G::from_u64(0);
@@ -36652,23 +36258,19 @@ fn aiur_fn_400(
         let __v_8: G = G::from_u64(2);
         let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = []; 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 = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        break '__mc_0 [__v_14];
+        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_8, __v_9, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        break '__mc_0 [__v_12];
       },
       1u64 => {
         let __v_8: G = G::from_u64(2);
         let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; 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 = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        break '__mc_0 [__v_14];
+        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_8, __v_9, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        break '__mc_0 [__v_12];
       },
       _ => {
         return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
@@ -36683,7 +36285,7 @@ fn aiur_fn_400(
     let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_12: G = __loaded[0];
     let __v_13: G = __loaded[1];
     let __v_14: G = __loaded[2];
@@ -36692,7 +36294,7 @@ fn aiur_fn_400(
       2u64 => {
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_17: G = __loaded[0];
         let __v_18: G = __loaded[1];
         let __v_19: G = __loaded[2];
@@ -36713,7 +36315,7 @@ fn aiur_fn_400(
             let __v_29: G = G::from_u64(0);
             let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_24, __v_25, __v_29]; 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_30: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_31: G = __loaded[0];
             let __v_32: G = __loaded[1];
             let __v_33: G = __loaded[2];
@@ -36780,14 +36382,14 @@ fn aiur_fn_401(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_3 + __v_7);
@@ -36802,11 +36404,11 @@ fn aiur_fn_401(
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_9]; 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_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_401] = [__v_12];
         record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -36814,7 +36416,7 @@ fn aiur_fn_401(
       2u64 => {
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_3]; 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 __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -36831,7 +36433,7 @@ fn aiur_fn_401(
         let __v_19: G = __r_arr[0];
         let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__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[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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_4]; 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_734] = { let __args: [G; IN_734] = [__v_4]; 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_21: G = __r_arr[0];
         if (__v_21 != __v_19) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
@@ -36845,7 +36447,7 @@ fn aiur_fn_401(
       3u64 => {
         let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
         let __v_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -36862,7 +36464,7 @@ fn aiur_fn_401(
           _ => {
             let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_6, __v_1]; 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_11: G = __r_arr[0];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_12: G = __loaded[0];
             let __v_13: G = __loaded[1];
             let __v_14: G = __loaded[2];
@@ -36884,30 +36486,28 @@ fn aiur_fn_401(
         }
       },
       4u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __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(5);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_401] = [__v_11];
+        let __v_6: G = { let __values: [G; 2] = [__v_3, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4, __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(5);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_3, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_401] = [__v_10];
         record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_3, __v_1]; 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_6: G = __r_arr[0];
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_4, __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 __v_9: G = __r_arr[0];
-        let __v_10: G = G::from_u64(1);
-        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_9]; 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_11: G = __r_arr[0];
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_401] = [__v_13];
+        let __v_7: G = { let __values: [G; 2] = [__v_3, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_4, __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 __v_8: G = __r_arr[0];
+        let __v_9: G = G::from_u64(1);
+        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_8]; 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_10: G = __r_arr[0];
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_401] = [__v_12];
         record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -36927,12 +36527,10 @@ fn aiur_fn_401(
             let __v_6: G = G::from_u64(2);
             let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = []; 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_7: G = __r_arr[0];
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_11: G = G::from_u64(0);
-            let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_401] = [__v_12];
+            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_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_401] = [__v_10];
             record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -36940,12 +36538,10 @@ fn aiur_fn_401(
             let __v_6: G = G::from_u64(2);
             let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; 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 = G::from_u64(1);
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_11: G = G::from_u64(0);
-            let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_401] = [__v_12];
+            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_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_401] = [__v_10];
             record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -36962,7 +36558,7 @@ fn aiur_fn_401(
         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 __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
@@ -36971,7 +36567,7 @@ fn aiur_fn_401(
           2u64 => {
             let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_15: G = __loaded[0];
             let __v_16: G = __loaded[1];
             let __v_17: G = __loaded[2];
@@ -36992,7 +36588,7 @@ fn aiur_fn_401(
                 let __v_27: G = G::from_u64(0);
                 let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_22, __v_23, __v_27]; 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_28: G = __r_arr[0];
-                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                 let __v_29: G = __loaded[0];
                 let __v_30: G = __loaded[1];
                 let __v_31: G = __loaded[2];
@@ -37058,7 +36654,7 @@ fn aiur_fn_402(
     let __v_1: G = inp[1];
     let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -37072,7 +36668,7 @@ fn aiur_fn_402(
       _ => {
         let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_2, __v_1]; 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 __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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -37112,32 +36708,38 @@ fn aiur_fn_403(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_3: G = __loaded[0];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
         let __v_6: G = __loaded[3];
         match __v_3.as_canonical_u64() {
           5u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_7: G = __loaded[0];
-            let __v_8: G = __loaded[1];
-            let __v_9: G = __loaded[2];
-            match __v_7.as_canonical_u64() {
+            match __v_1.as_canonical_u64() {
               0u64 => {
-                let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_8, __v_10]; 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_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_403] = { let __args: [G; IN_403] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } };
-                let __v_14: G = __r_arr[0];
-                let __ret: [G; OUT_403] = [__v_14];
+                let __v_7: G = G::from_u64(0);
+                let __v_8: G = G::from_u64(1);
+                if (__v_7 != __v_8) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                }
+                let __ret: [G; OUT_403] = [__v_7];
                 record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                let __v_7: G = __loaded[0];
+                let __v_8: G = __loaded[1];
+                let __v_9: G = G::from_u64(0);
+                let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __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 = G::from_u64(1);
+                let __v_12: G = (__v_2 - __v_11);
+                let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_10, __v_8, __v_12]; 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_13: G = __r_arr[0];
+                let __ret: [G; OUT_403] = [__v_13];
+                record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
@@ -37165,7 +36767,7 @@ fn aiur_fn_404(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -37181,7 +36783,7 @@ fn aiur_fn_404(
           },
           _ => {
             let __v_10: G = G::from_u64(8);
-            let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_12: G = G::from_u64(0);
             let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_7, __v_11, __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];
@@ -37214,70 +36816,58 @@ fn aiur_fn_405(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_405] = [__v_8];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_2: G = G::from_u64(1);
+            let __ret: [G; OUT_405] = [__v_2];
             record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_405] = [__v_8];
+            let __v_2: G = G::from_u64(0);
+            let __ret: [G; OUT_405] = [__v_2];
             record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_405] = [__v_8];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_405] = [__v_4];
             record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            match __v_8.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_4: G = __loaded[0];
+            let __v_5: G = __loaded[1];
+            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            match __v_6.as_canonical_u64() {
               0u64 => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_405] = [__v_9];
+                let __v_7: G = G::from_u64(0);
+                let __ret: [G; OUT_405] = [__v_7];
                 record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_4, __v_7]; 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_405] = [__v_9];
+                let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_3, __v_5]; 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_7: G = __r_arr[0];
+                let __ret: [G; OUT_405] = [__v_7];
                 record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -37312,12 +36902,10 @@ fn aiur_fn_406(
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           0u64 => {
-            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_408] = { let __args: [G; IN_408] = [__v_0, __v_1, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_406] = [__v_10];
+            let __v_7: G = G::from_u64(0);
+            let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } else { aiur_fn_408(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __ret: [G; OUT_406] = [__v_8];
             record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -37356,7 +36944,7 @@ fn aiur_fn_407(
     let __v_7: G = __r_arr[0];
     let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_2]; 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_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 __v_9: G = __r_arr[0];
     let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
@@ -37377,7 +36965,7 @@ fn aiur_fn_407(
         let __v_13: G = G::from_u64(0);
         let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1, __v_10, __v_13]; 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_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2, __v_10]; 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_736] = { let __args: [G; IN_736] = [__v_2, __v_10]; 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_15: G = __r_arr[0];
         let __v_16: G = (__v_3 - __v_10);
         let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_15, __v_16]; 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)? } };
@@ -37477,14 +37065,14 @@ fn aiur_fn_410(
     let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_7: G = __loaded[0];
     let __v_8: G = __loaded[1];
     let __v_9: G = __loaded[2];
     let __v_10: G = __loaded[3];
     match __v_7.as_canonical_u64() {
       2u64 => {
-        let __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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_11: G = __loaded[0];
         let __v_12: G = __loaded[1];
         let __v_13: G = __loaded[2];
@@ -37504,9 +37092,9 @@ fn aiur_fn_410(
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_4]; 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_734] = { let __args: [G; IN_734] = [__v_4]; 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_17: G = __r_arr[0];
-                    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
                     let __v_18: G = __r_arr[0];
                     let __v_19: G = (__v_17 - __v_18);
                     match __v_19.as_canonical_u64() {
@@ -37566,70 +37154,58 @@ fn aiur_fn_411(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __v_9: G = G::from_u64(1);
-            let __ret: [G; OUT_411] = [__v_9];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_3: G = G::from_u64(1);
+            let __ret: [G; OUT_411] = [__v_3];
             record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_411] = [__v_9];
+            let __v_3: G = G::from_u64(0);
+            let __ret: [G; OUT_411] = [__v_3];
             record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_411] = [__v_9];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_5: G = G::from_u64(0);
+            let __ret: [G; OUT_411] = [__v_5];
             record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_4, __v_7, __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];
-            match __v_9.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_5: G = __loaded[0];
+            let __v_6: G = __loaded[1];
+            let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_3, __v_5, __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_7: G = __r_arr[0];
+            match __v_7.as_canonical_u64() {
               0u64 => {
-                let __v_10: G = G::from_u64(0);
-                let __ret: [G; OUT_411] = [__v_10];
+                let __v_8: G = G::from_u64(0);
+                let __ret: [G; OUT_411] = [__v_8];
                 record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_5, __v_8, __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_10: G = __r_arr[0];
-                let __ret: [G; OUT_411] = [__v_10];
+                let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_4, __v_6, __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_8: G = __r_arr[0];
+                let __ret: [G; OUT_411] = [__v_8];
                 record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -37645,7 +37221,7 @@ fn aiur_fn_412(
 ) -> Result<[G; OUT_412], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -37698,7 +37274,7 @@ fn aiur_fn_413(
 ) -> Result<[G; OUT_413], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -37708,28 +37284,24 @@ fn aiur_fn_413(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(1);
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_413] = [__v_5, __v_9, __v_3];
+            let __v_6: G = G::from_u64(0);
+            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__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_7: G = __r_arr[0];
+            let __ret: [G; OUT_413] = [__v_5, __v_7, __v_3];
             record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_5: G = G::from_u64(0);
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_413] = [__v_5, __v_0, __v_8];
+            let __v_6: G = G::from_u64(0);
+            let __ret: [G; OUT_413] = [__v_5, __v_0, __v_6];
             record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -37755,17 +37327,15 @@ fn aiur_fn_413(
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __v_12: G = G::from_u64(1);
-                let __v_13: G = G::from_u64(1);
-                let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_413] = [__v_11, __v_0, __v_14];
+                let __v_12: G = G::from_u64(0);
+                let __ret: [G; OUT_413] = [__v_11, __v_0, __v_12];
                 record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           3u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_9: G = __loaded[0];
             let __v_10: G = __loaded[1];
             let __v_11: G = __loaded[2];
@@ -37778,7 +37348,7 @@ fn aiur_fn_413(
                 let __v_14: G = __r_arr[0];
                 match __v_14.as_canonical_u64() {
                   1u64 => {
-                    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                     let __v_15: G = __loaded[0];
                     let __v_16: G = __loaded[1];
                     let __v_17: G = __loaded[2];
@@ -37810,10 +37380,8 @@ fn aiur_fn_413(
                           },
                           _ => {
                             let __v_19: G = G::from_u64(0);
-                            let __v_20: G = G::from_u64(1);
-                            let __v_21: G = G::from_u64(1);
-                            let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_413] = [__v_19, __v_0, __v_22];
+                            let __v_20: G = G::from_u64(0);
+                            let __ret: [G; OUT_413] = [__v_19, __v_0, __v_20];
                             record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
@@ -37821,10 +37389,8 @@ fn aiur_fn_413(
                       },
                       _ => {
                         let __v_19: G = G::from_u64(0);
-                        let __v_20: G = G::from_u64(1);
-                        let __v_21: G = G::from_u64(1);
-                        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_413] = [__v_19, __v_0, __v_22];
+                        let __v_20: G = G::from_u64(0);
+                        let __ret: [G; OUT_413] = [__v_19, __v_0, __v_20];
                         record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
@@ -37832,10 +37398,8 @@ fn aiur_fn_413(
                   },
                   _ => {
                     let __v_15: G = G::from_u64(0);
-                    let __v_16: G = G::from_u64(1);
-                    let __v_17: G = G::from_u64(1);
-                    let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_413] = [__v_15, __v_0, __v_18];
+                    let __v_16: G = G::from_u64(0);
+                    let __ret: [G; OUT_413] = [__v_15, __v_0, __v_16];
                     record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
@@ -37843,10 +37407,8 @@ fn aiur_fn_413(
               },
               _ => {
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = G::from_u64(1);
-                let __v_15: G = G::from_u64(1);
-                let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_413] = [__v_13, __v_0, __v_16];
+                let __v_14: G = G::from_u64(0);
+                let __ret: [G; OUT_413] = [__v_13, __v_0, __v_14];
                 record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -37854,10 +37416,8 @@ fn aiur_fn_413(
           },
           _ => {
             let __v_9: G = G::from_u64(0);
-            let __v_10: G = G::from_u64(1);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_413] = [__v_9, __v_0, __v_12];
+            let __v_10: G = G::from_u64(0);
+            let __ret: [G; OUT_413] = [__v_9, __v_0, __v_10];
             record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -37865,10 +37425,8 @@ fn aiur_fn_413(
       },
       _ => {
         let __v_5: G = G::from_u64(0);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_413] = [__v_5, __v_0, __v_8];
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_413] = [__v_5, __v_0, __v_6];
         record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -37993,7 +37551,7 @@ fn aiur_fn_416(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -38149,14 +37707,14 @@ fn aiur_fn_419(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -38178,7 +37736,7 @@ fn aiur_fn_419(
         }
       },
       4u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -38189,11 +37747,10 @@ fn aiur_fn_419(
             let __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __v_12: G = G::from_u64(0);
-                let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_5, __v_9, __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_419] = [__v_14];
+                let __v_12: G = { let __values: [G; 2] = [__v_4, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_5, __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 __v_13: G = __r_arr[0];
+                let __ret: [G; OUT_419] = [__v_13];
                 record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -38214,7 +37771,7 @@ fn aiur_fn_419(
         }
       },
       5u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -38225,11 +37782,10 @@ fn aiur_fn_419(
             let __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __v_12: G = G::from_u64(0);
-                let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_5, __v_9, __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_419] = [__v_14];
+                let __v_12: G = { let __values: [G; 2] = [__v_4, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_5, __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 __v_13: G = __r_arr[0];
+                let __ret: [G; OUT_419] = [__v_13];
                 record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -38396,7 +37952,7 @@ fn aiur_fn_421(
     let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -38405,7 +37961,7 @@ fn aiur_fn_421(
       2u64 => {
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
@@ -38420,7 +37976,7 @@ fn aiur_fn_421(
         let __v_21: G = __loaded[11];
         match __v_10.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_4]; 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_734] = { let __args: [G; IN_734] = [__v_4]; 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_22: G = __r_arr[0];
             let __v_23: G = (__v_16 + __v_17);
             let __v_24: G = (__v_22 - __v_23);
@@ -38428,7 +37984,7 @@ fn aiur_fn_421(
               0u64 => {
                 let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_13, __v_14]; 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_25: G = __r_arr[0];
-                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                 let __v_26: G = __loaded[0];
                 let __v_27: G = __loaded[1];
                 let __v_28: G = __loaded[2];
@@ -38556,9 +38112,9 @@ fn aiur_fn_422(
       },
       _ => {
         let __v_8: G = G::from_u64(8);
-        let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_10: G = (__v_1 + __v_5);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_10]; 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_727] = { let __args: [G; IN_727] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
@@ -38607,23 +38163,15 @@ fn aiur_fn_423(
     let __v_9: G = __r_arr[7];
     let __v_10: G = G::from_u64(6);
     let __v_11: G = G::from_u64(0);
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = G::from_u64(1);
-    let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_15: G = G::from_u64(1);
-    let __v_16: G = G::from_u64(1);
-    let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_18: G = G::from_u64(1);
-    let __v_19: G = G::from_u64(1);
-    let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_21: G = G::from_u64(1);
-    let __v_22: G = G::from_u64(1);
-    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
-    let __v_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
-    let __v_25: G = __r_arr[0];
-    let __ret: [G; OUT_423] = [__v_25];
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = G::from_u64(0);
+    let __v_14: G = G::from_u64(0);
+    let __v_15: G = G::from_u64(0);
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_12, __v_13, __v_14, __v_15]; 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_16: G = __r_arr[0];
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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_17: G = __r_arr[0];
+    let __ret: [G; OUT_423] = [__v_17];
     record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -38642,14 +38190,14 @@ fn aiur_fn_424(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       4u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -38671,7 +38219,7 @@ fn aiur_fn_424(
         }
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -38749,7 +38297,7 @@ fn aiur_fn_426(
     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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -38758,7 +38306,7 @@ fn aiur_fn_426(
       2u64 => {
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -38782,7 +38330,7 @@ fn aiur_fn_426(
                     let __v_22: G = G::from_u64(0);
                     let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_15, __v_16, __v_22]; 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_23: G = __r_arr[0];
-                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                     let __v_24: G = __loaded[0];
                     let __v_25: G = __loaded[1];
                     let __v_26: G = __loaded[2];
@@ -38909,7 +38457,7 @@ fn aiur_fn_428(
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
     let __v_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_6: G = __loaded[0];
     let __v_7: G = __loaded[1];
     let __v_8: G = __loaded[2];
@@ -38933,15 +38481,14 @@ fn aiur_fn_428(
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
             let __v_16: G = G::from_u64(0);
-            let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_18: G = G::from_u64(3);
             let __v_19: G = G::from_u64(0);
-            let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_21: G = G::from_u64(0);
-            let __v_22: G = { let __values: [G; 3] = [__v_21, __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_406] = { let __args: [G; IN_406] = [__v_1, __v_20, __v_22]; 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_23: G = __r_arr[0];
-            let __ret: [G; OUT_428] = [__v_23];
+            let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_21: G = { let __values: [G; 2] = [__v_0, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_1, __v_20, __v_21]; 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_22: G = __r_arr[0];
+            let __ret: [G; OUT_428] = [__v_22];
             record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -38973,14 +38520,14 @@ fn aiur_fn_429(
     let __v_2: G = __r_arr[0];
     let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_2, __v_1]; 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_3: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -39043,14 +38590,14 @@ fn aiur_fn_431(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -39082,7 +38629,7 @@ fn aiur_fn_431(
         }
       },
       1u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -39104,7 +38651,7 @@ fn aiur_fn_431(
         }
       },
       2u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -39140,7 +38687,7 @@ fn aiur_fn_431(
         }
       },
       3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -39188,7 +38735,7 @@ fn aiur_fn_431(
         }
       },
       4u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -39205,11 +38752,10 @@ fn aiur_fn_431(
                 return Ok(__ret);
               },
               _ => {
-                let __v_12: G = G::from_u64(0);
-                let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_5, __v_9, __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_431] = [__v_14];
+                let __v_12: G = { let __values: [G; 2] = [__v_4, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_5, __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 __v_13: G = __r_arr[0];
+                let __ret: [G; OUT_431] = [__v_13];
                 record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -39225,7 +38771,7 @@ fn aiur_fn_431(
         }
       },
       5u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -39242,11 +38788,10 @@ fn aiur_fn_431(
                 return Ok(__ret);
               },
               _ => {
-                let __v_12: G = G::from_u64(0);
-                let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_5, __v_9, __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_431] = [__v_14];
+                let __v_12: G = { let __values: [G; 2] = [__v_4, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_5, __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 __v_13: G = __r_arr[0];
+                let __ret: [G; OUT_431] = [__v_13];
                 record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -39267,7 +38812,7 @@ fn aiur_fn_431(
         return Ok(__ret);
       },
       7u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -39303,7 +38848,7 @@ fn aiur_fn_431(
         }
       },
       8u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -39504,7 +39049,7 @@ fn aiur_fn_434(
     let __v_5: G = inp[5];
     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; 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 __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_7: G = __loaded[0];
     let __v_8: G = __loaded[1];
     let __v_9: G = __loaded[2];
@@ -39519,7 +39064,7 @@ fn aiur_fn_434(
     let __v_18: G = __loaded[11];
     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_1]; 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_19: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_20: G = __loaded[0];
     let __v_21: G = __loaded[1];
     let __v_22: G = __loaded[2];
@@ -39753,7 +39298,7 @@ fn aiur_fn_438(
     let __v_4: G = inp[4];
     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; 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_5: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_6: G = __loaded[0];
     let __v_7: G = __loaded[1];
     let __v_8: G = __loaded[2];
@@ -39860,7 +39405,7 @@ fn aiur_fn_439(
     let __v_4: G = inp[4];
     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; 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_5: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_6: G = __loaded[0];
     let __v_7: G = __loaded[1];
     let __v_8: G = __loaded[2];
@@ -40117,7 +39662,7 @@ fn aiur_fn_442(
     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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -40130,7 +39675,7 @@ fn aiur_fn_442(
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(8);
-            let __v_10: G = { let __values: [G; 4] = [__v_9, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_10: G = { let __values: [G; 4] = [__v_9, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_11: G = G::from_u64(1);
             let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_10, __v_2]; 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_12: G = __r_arr[0];
@@ -40170,7 +39715,7 @@ fn aiur_fn_443(
     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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -40179,7 +39724,7 @@ fn aiur_fn_443(
       2u64 => {
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -40268,7 +39813,7 @@ fn aiur_fn_444(
           _ => {
             let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_8: G = __loaded[0];
             let __v_9: G = __loaded[1];
             let __v_10: G = __loaded[2];
@@ -40283,7 +39828,7 @@ fn aiur_fn_444(
             let __v_19: G = __loaded[11];
             let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_21: G = __loaded[0];
             let __v_22: G = __loaded[1];
             let __v_23: G = __loaded[2];
@@ -40363,7 +39908,7 @@ fn aiur_fn_445(
     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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -40408,7 +39953,7 @@ fn aiur_fn_445(
         let __v_36: G = G::from_u64(0);
         let __v_37: G = G::from_u64(0);
         let __v_38: G = G::from_u64(0);
-        let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_40: G = G::from_u64(0);
         let __ret: [G; OUT_445] = [__v_39, __v_40];
         record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -40531,14 +40076,14 @@ fn aiur_fn_448(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_3 + __v_7);
@@ -40553,11 +40098,11 @@ fn aiur_fn_448(
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_9]; 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_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_448] = [__v_12];
         record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -40565,7 +40110,7 @@ fn aiur_fn_448(
       2u64 => {
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_3]; 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 __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -40580,7 +40125,7 @@ fn aiur_fn_448(
         let __v_18: G = __loaded[11];
         let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__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[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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_4]; 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_734] = { let __args: [G; IN_734] = [__v_4]; 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_20: G = __r_arr[0];
         let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__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[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_21: G = __r_arr[0];
@@ -40599,42 +40144,38 @@ fn aiur_fn_448(
         let __v_7: G = __r_arr[1];
         let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_6, __v_1]; 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 __v_9: G = G::from_u64(1);
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_8, __v_7, __v_11, __v_1]; 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_12: G = __r_arr[0];
-        let __ret: [G; OUT_448] = [__v_12];
+        let __v_9: G = G::from_u64(0);
+        let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_8, __v_7, __v_9, __v_1]; 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_10: G = __r_arr[0];
+        let __ret: [G; OUT_448] = [__v_10];
         record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_3, __v_1]; 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 __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_4, __v_8]; 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_9: G = __r_arr[0];
-        let __v_10: G = G::from_u64(5);
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_448] = [__v_12];
+        let __v_7: G = { let __values: [G; 2] = [__v_3, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } else { aiur_fn_447(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = G::from_u64(5);
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_448] = [__v_11];
         record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_3, __v_1]; 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 __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __v_10: G = G::from_u64(1);
-        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_9]; 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_11: G = __r_arr[0];
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_448] = [__v_13];
+        let __v_7: G = { let __values: [G; 2] = [__v_3, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_4, __v_7]; 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_8: G = __r_arr[0];
+        let __v_9: G = G::from_u64(1);
+        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_8]; 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_10: G = __r_arr[0];
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_448] = [__v_12];
         record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -40686,109 +40227,101 @@ fn aiur_fn_449(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_2]; 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_7: G = __r_arr[0];
-        match __v_7.as_canonical_u64() {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        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 __v_4: G = __r_arr[0];
+        match __v_4.as_canonical_u64() {
           0u64 => {
             let __ret: [G; OUT_449] = [__v_0];
             record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_8: G = G::from_u64(0);
-            let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_8]; 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_9: G = __r_arr[0];
-            let __ret: [G; OUT_449] = [__v_9];
+            let __v_5: G = G::from_u64(0);
+            let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_5]; 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 __ret: [G; OUT_449] = [__v_6];
             record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        let __v_10: G = __loaded[3];
-        match __v_7.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        let __v_9: G = __loaded[3];
+        match __v_6.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() {
+            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 __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];
+    break '__mc_0 [__v_7];
   },
   _ => {
-    let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    break '__mc_0 [__v_13];
+    let __v_11: G = G::from_u64(0);
+    let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_7, __v_2, __v_11]; 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_12: G = __r_arr[0];
+    break '__mc_0 [__v_12];
   },
 }
  };
-            let __v_12: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_5, __v_12, __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_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_9, __v_6, __v_14, __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_15: G = __r_arr[0];
-            let __ret: [G; OUT_449] = [__v_15];
+            let __v_11: G = __mc_out___mc_0[0];
+            let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_4, __v_11, __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_12: G = { let __values: [G; 2] = [__v_4, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_8, __v_5, __v_12, __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_13: G = __r_arr[0];
+            let __ret: [G; OUT_449] = [__v_13];
             record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() {
+            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 __v_10: G = __r_arr[0];
+            let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_10.as_canonical_u64() {
   0u64 => {
     break '__mc_1 [__v_0];
   },
   _ => {
-    let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    break '__mc_1 [__v_13];
+    let __v_11: G = G::from_u64(0);
+    let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_11]; 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_12: G = __r_arr[0];
+    break '__mc_1 [__v_12];
   },
 }
  };
-            let __v_12: G = __mc_out___mc_1[0];
-            let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-            let __v_14: G = __loaded[0];
-            let __v_15: G = __loaded[1];
-            let __v_16: G = __loaded[2];
-            let __v_17: G = __loaded[3];
-            match __v_14.as_canonical_u64() {
+            let __v_11: G = __mc_out___mc_1[0];
+            let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
+            let __v_12: 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_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __v_13: G = __loaded[0];
+            let __v_14: G = __loaded[1];
+            let __v_15: G = __loaded[2];
+            let __v_16: G = __loaded[3];
+            match __v_13.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_5, __v_15, __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_18: G = G::from_u64(0);
-                let __v_19: G = G::from_u64(1);
-                let __v_20: G = G::from_u64(1);
-                let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_16, __v_6, __v_22, __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_23: G = __r_arr[0];
-                let __ret: [G; OUT_449] = [__v_23];
+                let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_4, __v_14, __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_17: G = G::from_u64(0);
+                let __v_18: G = { let __values: [G; 2] = [__v_4, __v_17]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_15, __v_5, __v_18, __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_19: G = __r_arr[0];
+                let __ret: [G; OUT_449] = [__v_19];
                 record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
               },
             }
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
     }
   })
 }
@@ -40810,12 +40343,10 @@ fn aiur_fn_450(
         let __v_2: G = G::from_u64(2);
         let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = []; 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_3: G = __r_arr[0];
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_450] = [__v_8];
+        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_2, __v_3, __v_4, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_450] = [__v_6];
         record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -40823,12 +40354,10 @@ fn aiur_fn_450(
         let __v_2: G = G::from_u64(2);
         let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; 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_3: G = __r_arr[0];
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_450] = [__v_8];
+        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_2, __v_3, __v_4, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_450] = [__v_6];
         record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -40857,7 +40386,7 @@ fn aiur_fn_451(
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_4, __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_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_6: G = __loaded[0];
     let __v_7: G = __loaded[1];
     let __v_8: G = __loaded[2];
@@ -40866,7 +40395,7 @@ fn aiur_fn_451(
       1u64 => {
         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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_7, __v_12]; 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_13: G = __r_arr[0];
         let __ret: [G; OUT_451] = [__v_13];
@@ -40904,20 +40433,19 @@ fn aiur_fn_452(
       _ => {
         let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_4: G = __loaded[0];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
         let __v_7: G = __loaded[3];
         match __v_4.as_canonical_u64() {
           5u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_10: G = G::from_u64(1);
-            let __v_11: G = (__v_1 - __v_10);
-            let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_6, __v_11, __v_9]; 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_12: G = __r_arr[0];
-            let __ret: [G; OUT_452] = [__v_12];
+            let __v_8: G = { let __values: [G; 2] = [__v_5, __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() + 1); __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_452] = { let __args: [G; IN_452] = [__v_6, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __ret: [G; OUT_452] = [__v_11];
             record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -40956,7 +40484,7 @@ fn aiur_fn_453(
         let __v_3: G = __r_arr[0];
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(1);
@@ -40996,7 +40524,7 @@ fn aiur_fn_454(
         let __v_4: G = __r_arr[0];
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
@@ -41039,7 +40567,7 @@ fn aiur_fn_455(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_7: G = __loaded[0];
     let __v_8: G = __loaded[1];
     let __v_9: G = __loaded[2];
@@ -41057,7 +40585,7 @@ fn aiur_fn_455(
           _ => {
             let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_8, __v_9, __v_6]; 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 = G::from_u64(8);
-            let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_14: G = G::from_u64(0);
             let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_9, __v_13, __v_14]; 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_15: G = __r_arr[0];
@@ -41099,7 +40627,7 @@ fn aiur_fn_456(
     let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_8: G = __loaded[0];
     let __v_9: G = __loaded[1];
     let __v_10: G = __loaded[2];
@@ -41108,7 +40636,7 @@ fn aiur_fn_456(
       2u64 => {
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_9]; 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_12: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_13: G = __loaded[0];
         let __v_14: G = __loaded[1];
         let __v_15: G = __loaded[2];
@@ -41129,7 +40657,7 @@ fn aiur_fn_456(
             let __v_25: G = G::from_u64(0);
             let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_20, __v_21, __v_25]; 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_26: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_27: G = __loaded[0];
             let __v_28: G = __loaded[1];
             let __v_29: G = __loaded[2];
@@ -41195,7 +40723,7 @@ fn aiur_fn_457(
     let __v_2: G = __r_arr[0];
     let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_2, __v_1]; 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_3: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -41282,7 +40810,7 @@ fn aiur_fn_459(
     let __v_29: G = G::from_u64(35);
     let __v_30: G = G::from_u64(119);
     let __v_31: G = G::from_u64(227);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_459] = [__v_32];
     record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -41331,7 +40859,7 @@ fn aiur_fn_460(
     let __v_29: G = G::from_u64(106);
     let __v_30: G = G::from_u64(36);
     let __v_31: G = G::from_u64(1);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_460] = [__v_32];
     record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -41380,7 +40908,7 @@ fn aiur_fn_461(
     let __v_29: G = G::from_u64(174);
     let __v_30: G = G::from_u64(255);
     let __v_31: G = G::from_u64(33);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_461] = [__v_32];
     record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -41429,7 +40957,7 @@ fn aiur_fn_462(
     let __v_29: G = G::from_u64(169);
     let __v_30: G = G::from_u64(131);
     let __v_31: G = G::from_u64(129);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_462] = [__v_32];
     record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -41478,7 +41006,7 @@ fn aiur_fn_463(
     let __v_29: G = G::from_u64(188);
     let __v_30: G = G::from_u64(87);
     let __v_31: G = G::from_u64(149);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_463] = [__v_32];
     record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -41527,7 +41055,7 @@ fn aiur_fn_464(
     let __v_29: G = G::from_u64(247);
     let __v_30: G = G::from_u64(249);
     let __v_31: G = G::from_u64(186);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_464] = [__v_32];
     record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -41576,7 +41104,7 @@ fn aiur_fn_465(
     let __v_29: G = G::from_u64(229);
     let __v_30: G = G::from_u64(155);
     let __v_31: G = G::from_u64(194);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_465] = [__v_32];
     record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -41625,7 +41153,7 @@ fn aiur_fn_466(
     let __v_29: G = G::from_u64(211);
     let __v_30: G = G::from_u64(229);
     let __v_31: G = G::from_u64(199);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_466] = [__v_32];
     record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -41674,7 +41202,7 @@ fn aiur_fn_467(
     let __v_29: G = G::from_u64(7);
     let __v_30: G = G::from_u64(26);
     let __v_31: G = G::from_u64(212);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_467] = [__v_32];
     record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -41723,7 +41251,7 @@ fn aiur_fn_468(
     let __v_29: G = G::from_u64(201);
     let __v_30: G = G::from_u64(160);
     let __v_31: G = G::from_u64(164);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_468] = [__v_32];
     record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -41772,7 +41300,7 @@ fn aiur_fn_469(
     let __v_29: G = G::from_u64(167);
     let __v_30: G = G::from_u64(173);
     let __v_31: G = G::from_u64(206);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_469] = [__v_32];
     record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -41821,7 +41349,7 @@ fn aiur_fn_470(
     let __v_29: G = G::from_u64(21);
     let __v_30: G = G::from_u64(35);
     let __v_31: G = G::from_u64(127);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_470] = [__v_32];
     record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -41870,7 +41398,7 @@ fn aiur_fn_471(
     let __v_29: G = G::from_u64(26);
     let __v_30: G = G::from_u64(226);
     let __v_31: G = G::from_u64(199);
-    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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_471] = [__v_32];
     record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -41919,7 +41447,7 @@ fn aiur_fn_472(
     let __v_29: G = G::from_u64(7);
     let __v_30: G = G::from_u64(224);
     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 __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_472] = [__v_32];
     record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -41968,7 +41496,7 @@ fn aiur_fn_473(
     let __v_29: G = G::from_u64(132);
     let __v_30: G = G::from_u64(211);
     let __v_31: G = G::from_u64(220);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_473] = [__v_32];
     record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -42017,7 +41545,7 @@ fn aiur_fn_474(
     let __v_29: G = G::from_u64(241);
     let __v_30: G = G::from_u64(73);
     let __v_31: G = G::from_u64(241);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_474] = [__v_32];
     record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -42197,14 +41725,14 @@ fn aiur_fn_477(
 ) -> Result<[G; OUT_477], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -42224,15 +41752,13 @@ fn aiur_fn_477(
               0u64 => {
                 let __v_14: G = G::from_u64(0);
                 let __v_15: G = G::from_u64(0);
-                let __v_16: G = G::from_u64(1);
-                let __v_17: G = G::from_u64(1);
-                let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_477] = [__v_14, __v_15, __v_18];
+                let __v_16: G = G::from_u64(0);
+                let __ret: [G; OUT_477] = [__v_14, __v_15, __v_16];
                 record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                 let __v_14: G = __loaded[0];
                 let __v_15: G = __loaded[1];
                 let __v_16: G = __loaded[2];
@@ -42249,10 +41775,8 @@ fn aiur_fn_477(
                       _ => {
                         let __v_18: G = G::from_u64(0);
                         let __v_19: G = G::from_u64(0);
-                        let __v_20: G = G::from_u64(1);
-                        let __v_21: G = G::from_u64(1);
-                        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_477] = [__v_18, __v_19, __v_22];
+                        let __v_20: G = G::from_u64(0);
+                        let __ret: [G; OUT_477] = [__v_18, __v_19, __v_20];
                         record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
@@ -42261,10 +41785,8 @@ fn aiur_fn_477(
                   _ => {
                     let __v_18: G = G::from_u64(0);
                     let __v_19: G = G::from_u64(0);
-                    let __v_20: G = G::from_u64(1);
-                    let __v_21: G = G::from_u64(1);
-                    let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_477] = [__v_18, __v_19, __v_22];
+                    let __v_20: G = G::from_u64(0);
+                    let __ret: [G; OUT_477] = [__v_18, __v_19, __v_20];
                     record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
@@ -42275,10 +41797,8 @@ fn aiur_fn_477(
           _ => {
             let __v_9: G = G::from_u64(0);
             let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = G::from_u64(1);
-            let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_477] = [__v_9, __v_10, __v_13];
+            let __v_11: G = G::from_u64(0);
+            let __ret: [G; OUT_477] = [__v_9, __v_10, __v_11];
             record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -42287,10 +41807,8 @@ fn aiur_fn_477(
       _ => {
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_477] = [__v_5, __v_6, __v_9];
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_477] = [__v_5, __v_6, __v_7];
         record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -42325,19 +41843,17 @@ fn aiur_fn_478(
  };
     let __v_2: G = __mc_out___mc_0[0];
     let __v_3: G = G::from_u64(2);
-    let __v_4: G = G::from_u64(1);
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_7: G = G::from_u64(0);
-    let __v_8: G = { let __values: [G; 4] = [__v_3, __v_2, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_9: G = G::from_u64(7);
-    let __v_10: G = G::from_u64(0);
-    let __v_11: G = G::from_u64(0);
-    let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_1, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_13: G = G::from_u64(3);
-    let __v_14: G = G::from_u64(0);
-    let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_478] = [__v_15];
+    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_3, __v_2, __v_4, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_7: G = G::from_u64(7);
+    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_1, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_11: G = G::from_u64(3);
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = { let __values: [G; 4] = [__v_11, __v_6, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_478] = [__v_13];
     record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -42357,7 +41873,7 @@ fn aiur_fn_479(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_2]; 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_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 __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 };
@@ -42367,17 +41883,17 @@ fn aiur_fn_479(
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_479] = [__v_7, __v_11];
         record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_7]; 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_727] = { let __args: [G; IN_727] = [__v_2, __v_7]; 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_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_9]; 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_727] = { let __args: [G; IN_727] = [__v_2, __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 __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
@@ -42395,7 +41911,7 @@ fn aiur_fn_479(
                 let __v_18: G = G::from_u64(0);
                 let __v_19: G = G::from_u64(0);
                 let __v_20: G = G::from_u64(0);
-                let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_479] = [__v_17, __v_21];
                 record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -42462,15 +41978,15 @@ fn aiur_fn_480(
             let __v_15: G = __r_arr[0];
             let __v_16: G = G::from_u64(2);
             let __v_17: G = G::from_u64(0);
-            let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_19: G = G::from_u64(3);
             let __v_20: G = G::from_u64(0);
-            let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_14, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_14, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_22: G = G::from_u64(3);
             let __v_23: G = G::from_u64(0);
-            let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_25: G = G::from_u64(2);
-            let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2, __v_25]; 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_736] = { let __args: [G; IN_736] = [__v_2, __v_25]; 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_26: G = __r_arr[0];
             let __v_27: G = G::from_u64(1);
             let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_24, __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)? } };
@@ -42484,7 +42000,7 @@ fn aiur_fn_480(
             let __v_15: G = G::from_u64(0);
             let __v_16: G = G::from_u64(0);
             let __v_17: G = G::from_u64(0);
-            let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_480] = [__v_14, __v_18];
             record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -42496,7 +42012,7 @@ fn aiur_fn_480(
         let __v_12: G = G::from_u64(0);
         let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_480] = [__v_11, __v_15];
         record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -42519,7 +42035,7 @@ fn aiur_fn_481(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_2]; 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_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 __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 };
@@ -42529,7 +42045,7 @@ fn aiur_fn_481(
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_481] = [__v_7, __v_11];
         record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -42598,10 +42114,10 @@ fn aiur_fn_482(
     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_726] = { let __args: [G; IN_726] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = G::from_u64(1);
-    let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_5]; 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_727] = { let __args: [G; IN_727] = [__v_1, __v_5]; 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_6: G = __r_arr[0];
     let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
@@ -42614,7 +42130,7 @@ fn aiur_fn_482(
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
         let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_482] = [__v_10, __v_14];
         record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -42628,15 +42144,15 @@ fn aiur_fn_482(
         let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_16: G = G::from_u64(3);
         let __v_17: G = G::from_u64(0);
-        let __v_18: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_18: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_19: G = G::from_u64(3);
         let __v_20: G = G::from_u64(0);
-        let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_22: G = G::from_u64(2);
-        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_1, __v_22]; 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_736] = { let __args: [G; IN_736] = [__v_1, __v_22]; 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_23: G = __r_arr[0];
         let __v_24: G = G::from_u64(1);
         let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_21, __v_23]; 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)? } };
@@ -42669,10 +42185,10 @@ fn aiur_fn_483(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = G::from_u64(0);
-    let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
-    let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_7, __v_5]; 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_10: G = __r_arr[0];
@@ -42687,7 +42203,7 @@ fn aiur_fn_483(
         let __v_15: G = G::from_u64(0);
         let __v_16: G = G::from_u64(0);
         let __v_17: G = G::from_u64(0);
-        let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_483] = [__v_14, __v_18];
         record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -42702,7 +42218,7 @@ fn aiur_fn_483(
             let __v_17: G = G::from_u64(0);
             let __v_18: G = G::from_u64(0);
             let __v_19: G = G::from_u64(0);
-            let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_483] = [__v_16, __v_20];
             record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -42769,7 +42285,7 @@ fn aiur_fn_484(
         let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
         let __v_15: G = G::from_u64(0);
-        let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_484] = [__v_12, __v_16];
         record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -42778,65 +42294,58 @@ fn aiur_fn_484(
         let __v_12: G = G::from_u64(1);
         let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_16: G = G::from_u64(0);
-        let __v_17: G = { let __values: [G; 3] = [__v_12, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_17: G = { let __values: [G; 3] = [__v_12, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_18: G = G::from_u64(0);
-        let __v_19: G = G::from_u64(1);
-        let __v_20: G = G::from_u64(1);
-        let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_23: G = G::from_u64(2);
+        let __v_19: G = { let __values: [G; 2] = [__v_17, __v_18]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_20: G = G::from_u64(2);
         let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = []; 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_24: G = __r_arr[0];
-        let __v_25: G = G::from_u64(0);
-        let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_27: G = G::from_u64(2);
+        let __v_21: G = __r_arr[0];
+        let __v_22: G = G::from_u64(0);
+        let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_19, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_24: G = G::from_u64(2);
         let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = []; 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_28: G = __r_arr[0];
-        let __v_29: G = G::from_u64(1);
-        let __v_30: G = G::from_u64(1);
-        let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_32: G = G::from_u64(0);
-        let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_25: G = __r_arr[0];
+        let __v_26: G = G::from_u64(0);
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = { let __values: [G; 4] = [__v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
   1u64 => {
     let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-    let __v_34: G = __r_arr[0];
-    break '__mc_0 [__v_34];
+    let __v_29: G = __r_arr[0];
+    break '__mc_0 [__v_29];
   },
   _ => {
     let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } else { aiur_fn_157(__args, record, io_buffer, __cu)? } };
-    let __v_34: G = __r_arr[0];
-    break '__mc_0 [__v_34];
+    let __v_29: G = __r_arr[0];
+    break '__mc_0 [__v_29];
   },
 }
  };
-        let __v_34: G = __mc_out___mc_0[0];
-        let __v_35: G = G::from_u64(2);
-        let __v_36: G = G::from_u64(1);
-        let __v_37: G = G::from_u64(1);
-        let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_39: G = G::from_u64(0);
-        let __v_40: G = { let __values: [G; 4] = [__v_35, __v_34, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_41: G = G::from_u64(3);
-        let __v_42: G = G::from_u64(0);
-        let __v_43: G = { let __values: [G; 4] = [__v_41, __v_26, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_44: G = G::from_u64(3);
-        let __v_45: G = G::from_u64(0);
-        let __v_46: G = { let __values: [G; 4] = [__v_44, __v_43, __v_40, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_29: G = __mc_out___mc_0[0];
+        let __v_30: G = G::from_u64(2);
+        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_29, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_34: G = G::from_u64(3);
+        let __v_35: G = G::from_u64(0);
+        let __v_36: G = { let __values: [G; 4] = [__v_34, __v_23, __v_28, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_37: G = G::from_u64(3);
+        let __v_38: G = G::from_u64(0);
+        let __v_39: G = { let __values: [G; 4] = [__v_37, __v_36, __v_33, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_0.as_canonical_u64() {
   1u64 => {
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = []; 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_47: G = __r_arr[0];
-        break '__mc_1 [__v_47];
+        let __v_40: G = __r_arr[0];
+        break '__mc_1 [__v_40];
       },
       _ => {
         let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = []; 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_47: G = __r_arr[0];
-        break '__mc_1 [__v_47];
+        let __v_40: G = __r_arr[0];
+        break '__mc_1 [__v_40];
       },
     }
   },
@@ -42844,38 +42353,36 @@ fn aiur_fn_484(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = []; 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_47: G = __r_arr[0];
-        break '__mc_1 [__v_47];
+        let __v_40: G = __r_arr[0];
+        break '__mc_1 [__v_40];
       },
       _ => {
         let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = []; 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_47: G = __r_arr[0];
-        break '__mc_1 [__v_47];
+        let __v_40: G = __r_arr[0];
+        break '__mc_1 [__v_40];
       },
     }
   },
 }
  };
-        let __v_47: G = __mc_out___mc_1[0];
-        let __v_48: G = G::from_u64(2);
-        let __v_49: G = G::from_u64(1);
-        let __v_50: G = G::from_u64(1);
-        let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_40: G = __mc_out___mc_1[0];
+        let __v_41: G = G::from_u64(2);
+        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_40, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_45: G = G::from_u64(3);
+        let __v_46: G = G::from_u64(0);
+        let __v_47: G = { let __values: [G; 4] = [__v_45, __v_44, __v_3, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_48: G = G::from_u64(3);
+        let __v_49: G = G::from_u64(0);
+        let __v_50: G = { let __values: [G; 4] = [__v_48, __v_47, __v_4, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        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_48, __v_47, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_54: G = G::from_u64(3);
-        let __v_55: G = G::from_u64(0);
-        let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_3, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_57: G = G::from_u64(3);
-        let __v_58: G = G::from_u64(0);
-        let __v_59: G = { let __values: [G; 4] = [__v_57, __v_56, __v_4, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_60: G = G::from_u64(3);
-        let __v_61: G = G::from_u64(0);
-        let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; 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_63: G = __r_arr[0];
-        let __v_64: G = __r_arr[1];
-        let __ret: [G; OUT_484] = [__v_63, __v_64];
+        let __v_53: G = { let __values: [G; 4] = [__v_51, __v_50, __v_39, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_2, __v_53, __v_5, __v_6, __v_7, __v_8]; 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_54: G = __r_arr[0];
+        let __v_55: G = __r_arr[1];
+        let __ret: [G; OUT_484] = [__v_54, __v_55];
         record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -42896,7 +42403,7 @@ fn aiur_fn_485(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_1]; 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_734] = { let __args: [G; IN_734] = [__v_1]; 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_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(2);
     let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -42906,19 +42413,19 @@ fn aiur_fn_485(
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_485] = [__v_6, __v_10];
         record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(1);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
@@ -42927,7 +42434,7 @@ fn aiur_fn_485(
           7u64 => {
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                 let __v_14: G = __loaded[0];
                 let __v_15: G = __loaded[1];
                 let __v_16: G = __loaded[2];
@@ -42944,7 +42451,7 @@ fn aiur_fn_485(
                             let __v_20: G = G::from_u64(0);
                             let __v_21: G = G::from_u64(0);
                             let __v_22: G = G::from_u64(0);
-                            let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                             let __ret: [G; OUT_485] = [__v_19, __v_23];
                             record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
@@ -42964,7 +42471,7 @@ fn aiur_fn_485(
                         let __v_19: G = G::from_u64(0);
                         let __v_20: G = G::from_u64(0);
                         let __v_21: G = G::from_u64(0);
-                        let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                         let __ret: [G; OUT_485] = [__v_18, __v_22];
                         record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
@@ -42976,7 +42483,7 @@ fn aiur_fn_485(
                     let __v_19: G = G::from_u64(0);
                     let __v_20: G = G::from_u64(0);
                     let __v_21: G = G::from_u64(0);
-                    let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                     let __ret: [G; OUT_485] = [__v_18, __v_22];
                     record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -42988,7 +42495,7 @@ fn aiur_fn_485(
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __ret: [G; OUT_485] = [__v_14, __v_18];
                 record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -43000,7 +42507,7 @@ fn aiur_fn_485(
             let __v_15: G = G::from_u64(0);
             let __v_16: G = G::from_u64(0);
             let __v_17: G = G::from_u64(0);
-            let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_485] = [__v_14, __v_18];
             record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -43028,95 +42535,86 @@ fn aiur_fn_486(
     let __v_4: G = G::from_u64(1);
     let __v_5: G = G::from_u64(0);
     let __v_6: G = G::from_u64(0);
-    let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_8: G = G::from_u64(0);
-    let __v_9: G = { let __values: [G; 3] = [__v_4, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_9: G = { let __values: [G; 3] = [__v_4, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_10: G = G::from_u64(0);
-    let __v_11: G = G::from_u64(1);
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_15: G = G::from_u64(2);
+    let __v_11: G = { let __values: [G; 2] = [__v_9, __v_10]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_12: G = G::from_u64(2);
     let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = []; 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_16: G = __r_arr[0];
-    let __v_17: G = G::from_u64(0);
-    let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_19: G = G::from_u64(2);
+    let __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_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_16: G = G::from_u64(2);
     let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; 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 = G::from_u64(1);
+    let __v_17: G = __r_arr[0];
+    let __v_18: G = G::from_u64(0);
+    let __v_19: G = G::from_u64(0);
+    let __v_20: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_21: G = G::from_u64(7);
     let __v_22: G = G::from_u64(1);
-    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_24: G = G::from_u64(0);
-    let __v_25: G = { let __values: [G; 4] = [__v_19, __v_20, __v_23, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_26: G = G::from_u64(7);
-    let __v_27: G = G::from_u64(1);
-    let __v_28: G = G::from_u64(0);
-    let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_0, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_30: G = G::from_u64(3);
-    let __v_31: G = G::from_u64(0);
-    let __v_32: G = { let __values: [G; 4] = [__v_30, __v_18, __v_25, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_33: G = G::from_u64(3);
-    let __v_34: G = G::from_u64(0);
-    let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_29, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_36: G = G::from_u64(2);
-    let __v_37: G = G::from_u64(1);
-    let __v_38: G = G::from_u64(1);
-    let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_40: G = G::from_u64(0);
-    let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_42: G = G::from_u64(2);
-    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_2, __v_42]; 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_43: G = __r_arr[0];
-    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_41, __v_43]; 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_44: G = __r_arr[0];
-    let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_44, __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 __v_45: G = __r_arr[0];
-    let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
-    let __v_46: G = __r_arr[0];
-    let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_46]; 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_47: G = __r_arr[0];
-    let __v_48: G = __r_arr[1];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_48]; 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_49: G = __r_arr[0];
-    let __v_50: G = G::from_u64(1);
-    let __v_51: G = { let __a_val = __v_49.as_canonical_u64(); let __b_val = __v_50.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-    match __v_51.as_canonical_u64() {
+    let __v_23: G = G::from_u64(0);
+    let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_0, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_25: G = G::from_u64(3);
+    let __v_26: G = G::from_u64(0);
+    let __v_27: G = { let __values: [G; 4] = [__v_25, __v_15, __v_20, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_28: G = G::from_u64(3);
+    let __v_29: G = G::from_u64(0);
+    let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_24, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_31: G = G::from_u64(2);
+    let __v_32: G = G::from_u64(0);
+    let __v_33: G = G::from_u64(0);
+    let __v_34: G = { let __values: [G; 4] = [__v_31, __v_1, __v_32, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_35: G = G::from_u64(2);
+    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } };
+    let __v_36: G = __r_arr[0];
+    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_34, __v_36]; 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_37: G = __r_arr[0];
+    let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_37, __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 __v_38: G = __r_arr[0];
+    let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_38, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
+    let __v_39: G = __r_arr[0];
+    let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_39]; 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_40: G = __r_arr[0];
+    let __v_41: G = __r_arr[1];
+    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_41]; 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_42: G = __r_arr[0];
+    let __v_43: G = G::from_u64(1);
+    let __v_44: G = { let __a_val = __v_42.as_canonical_u64(); let __b_val = __v_43.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_44.as_canonical_u64() {
       1u64 => {
-        let __v_52: G = G::from_u64(0);
-        let __v_53: G = G::from_u64(0);
-        let __v_54: G = G::from_u64(0);
-        let __v_55: G = G::from_u64(0);
-        let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_486] = [__v_52, __v_56];
+        let __v_45: G = G::from_u64(0);
+        let __v_46: G = G::from_u64(0);
+        let __v_47: G = G::from_u64(0);
+        let __v_48: G = G::from_u64(0);
+        let __v_49: G = { let __values: [G; 4] = [__v_46, __v_47, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_486] = [__v_45, __v_49];
         record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_52: G = G::from_u64(0);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_48, __v_52]; 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_53: G = __r_arr[0];
-        let __v_54: G = G::from_u64(2);
+        let __v_45: G = G::from_u64(0);
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_41, __v_45]; 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_46: G = __r_arr[0];
+        let __v_47: G = G::from_u64(2);
         let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = []; 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_55: G = __r_arr[0];
-        let __v_56: G = G::from_u64(1);
-        let __v_57: G = G::from_u64(1);
-        let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_59: G = G::from_u64(0);
-        let __v_60: G = { let __values: [G; 4] = [__v_54, __v_55, __v_58, __v_59]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_61: G = G::from_u64(3);
-        let __v_62: G = G::from_u64(0);
-        let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __v_53, __v_62]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_64: G = G::from_u64(3);
-        let __v_65: G = G::from_u64(0);
-        let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_67: G = G::from_u64(2);
-        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2, __v_67]; 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_68: G = __r_arr[0];
-        let __v_69: G = G::from_u64(1);
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_66, __v_68]; 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_70: G = __r_arr[0];
-        let __ret: [G; OUT_486] = [__v_69, __v_70];
+        let __v_48: G = __r_arr[0];
+        let __v_49: G = G::from_u64(0);
+        let __v_50: G = G::from_u64(0);
+        let __v_51: G = { let __values: [G; 4] = [__v_47, __v_48, __v_49, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_52: G = G::from_u64(3);
+        let __v_53: G = G::from_u64(0);
+        let __v_54: G = { let __values: [G; 4] = [__v_52, __v_51, __v_46, __v_53]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_55: G = G::from_u64(3);
+        let __v_56: G = G::from_u64(0);
+        let __v_57: G = { let __values: [G; 4] = [__v_55, __v_54, __v_30, __v_56]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_58: G = G::from_u64(2);
+        let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_2, __v_58]; 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_59: G = __r_arr[0];
+        let __v_60: G = G::from_u64(1);
+        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_57, __v_59]; 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_61: G = __r_arr[0];
+        let __ret: [G; OUT_486] = [__v_60, __v_61];
         record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -43156,9 +42654,9 @@ fn aiur_fn_487(
     let __v_6: G = __mc_out___mc_0[0];
     let __v_7: G = G::from_u64(2);
     let __v_8: G = G::from_u64(0);
-    let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_10: G = G::from_u64(2);
-    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_4, __v_10]; 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_735] = { let __args: [G; IN_735] = [__v_4, __v_10]; 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_11: G = __r_arr[0];
     let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_9, __v_11]; 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_12: G = __r_arr[0];
@@ -43169,7 +42667,7 @@ fn aiur_fn_487(
     let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_16]; 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_734] = { let __args: [G; IN_734] = [__v_16]; 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_17: G = __r_arr[0];
     let __v_18: G = G::from_u64(1);
     let __v_19: G = { let __a_val = __v_17.as_canonical_u64(); let __b_val = __v_18.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -43179,34 +42677,32 @@ fn aiur_fn_487(
         let __v_21: G = G::from_u64(0);
         let __v_22: G = G::from_u64(0);
         let __v_23: G = G::from_u64(0);
-        let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_487] = [__v_20, __v_24];
         record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_20: G = G::from_u64(0);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_16, __v_20]; 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_727] = { let __args: [G; IN_727] = [__v_16, __v_20]; 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_21: G = __r_arr[0];
         let __v_22: G = G::from_u64(2);
-        let __v_23: G = G::from_u64(1);
-        let __v_24: G = G::from_u64(1);
-        let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_26: G = G::from_u64(0);
-        let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_28: G = G::from_u64(3);
-        let __v_29: G = G::from_u64(0);
-        let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_21, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_31: G = G::from_u64(3);
-        let __v_32: G = G::from_u64(0);
-        let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_34: G = G::from_u64(2);
-        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_4, __v_34]; 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_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_6, __v_23, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_26: G = G::from_u64(3);
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = { let __values: [G; 4] = [__v_26, __v_25, __v_21, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        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_28, __v_1, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_32: G = G::from_u64(2);
+        let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_4, __v_32]; 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_33: G = __r_arr[0];
+        let __v_34: G = G::from_u64(1);
+        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_31, __v_33]; 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_35: G = __r_arr[0];
-        let __v_36: G = G::from_u64(1);
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_33, __v_35]; 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_37: G = __r_arr[0];
-        let __ret: [G; OUT_487] = [__v_36, __v_37];
+        let __ret: [G; OUT_487] = [__v_34, __v_35];
         record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -43399,7 +42895,7 @@ fn aiur_fn_495(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -43432,7 +42928,7 @@ fn aiur_fn_495(
     let __v_31: G = __loaded[29];
     let __v_32: G = __loaded[30];
     let __v_33: G = __loaded[31];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_34: G = __loaded[0];
     let __v_35: G = __loaded[1];
     let __v_36: G = __loaded[2];
@@ -43557,41 +43053,37 @@ fn aiur_fn_497(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_497] = [__v_6];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_497] = [__v_2];
         record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        match __v_6.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        match __v_5.as_canonical_u64() {
           1u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = (__v_7 + __v_4);
-            let __ret: [G; OUT_497] = [__v_8];
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_6 + __v_3);
+            let __ret: [G; OUT_497] = [__v_7];
             record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_0, __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_7: G = __r_arr[0];
-            let __ret: [G; OUT_497] = [__v_7];
+            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __ret: [G; OUT_497] = [__v_6];
             record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -43686,13 +43178,13 @@ fn aiur_fn_499(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -43712,7 +43204,7 @@ fn aiur_fn_499(
         }
       },
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -43739,7 +43231,7 @@ fn aiur_fn_499(
         }
       },
       2u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -43776,7 +43268,7 @@ fn aiur_fn_499(
         }
       },
       3u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -43822,7 +43314,7 @@ fn aiur_fn_499(
         }
       },
       4u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -43861,62 +43353,50 @@ fn aiur_fn_500(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_500] = [__v_8];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_2: G = G::from_u64(1);
+            let __ret: [G; OUT_500] = [__v_2];
             record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_500] = [__v_8];
+            let __v_2: G = G::from_u64(0);
+            let __ret: [G; OUT_500] = [__v_2];
             record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_500] = [__v_8];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(2);
+            let __ret: [G; OUT_500] = [__v_4];
             record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __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 __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_4: G = __loaded[0];
+            let __v_5: G = __loaded[1];
+            let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_5]; 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_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_6, __v_7]; 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_4, __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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_500] = [__v_10];
+            let __ret: [G; OUT_500] = [__v_8];
             record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -43999,9 +43479,9 @@ fn aiur_fn_502(
     let __v_2: G = __r_arr[0];
     let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_2]; 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_728] = { let __args: [G; IN_728] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_3]; 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_5: G = __r_arr[0];
     let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_4, __v_5]; 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_6: G = __r_arr[0];
@@ -44034,56 +43514,58 @@ fn aiur_fn_503(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_503] = [__v_12];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_503] = [__v_2];
         record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__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[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_22, __v_23]; 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_24: G = __r_arr[0];
-            let __ret: [G; OUT_503] = [__v_24];
+            let __v_11: G = G::from_u64(0);
+            let __v_12: G = G::from_u64(1);
+            if (__v_11 != __v_12) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_503] = [__v_11];
             record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+            let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+            let __v_11: G = __loaded[0];
+            let __v_12: G = __loaded[1];
+            let __v_13: G = __loaded[2];
+            let __v_14: G = __loaded[3];
+            let __v_15: G = __loaded[4];
+            let __v_16: G = __loaded[5];
+            let __v_17: G = __loaded[6];
+            let __v_18: G = __loaded[7];
+            let __v_19: G = __loaded[8];
+            let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_10, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__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[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } };
+            let __v_21: G = __r_arr[0];
+            let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_20, __v_21]; 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_503] = [__v_22];
+            record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -44162,62 +43644,50 @@ fn aiur_fn_505(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_505] = [__v_8];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_2: G = G::from_u64(1);
+            let __ret: [G; OUT_505] = [__v_2];
             record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_505] = [__v_8];
+            let __v_2: G = G::from_u64(0);
+            let __ret: [G; OUT_505] = [__v_2];
             record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_505] = [__v_8];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(2);
+            let __ret: [G; OUT_505] = [__v_4];
             record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } };
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_4: G = __loaded[0];
+            let __v_5: G = __loaded[1];
+            let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_2, __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_6: G = __r_arr[0];
+            let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_6, __v_7]; 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_8: G = __r_arr[0];
-            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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_8, __v_9]; 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_505] = [__v_10];
+            let __ret: [G; OUT_505] = [__v_8];
             record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -44246,12 +43716,12 @@ fn aiur_fn_506(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_4: G = __loaded[0];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
         let __v_7: G = __loaded[3];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -44763,77 +44233,63 @@ fn aiur_fn_509(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-        let __v_8: G = __loaded[0];
-        let __v_9: G = __loaded[1];
-        let __v_10: G = __loaded[2];
-        let __v_11: G = __loaded[3];
-        let __v_12: G = __loaded[4];
-        match __v_8.as_canonical_u64() {
-          1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
             let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = []; 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_13: G = __r_arr[0];
-            let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_509] = [__v_13, __v_14];
+            let __v_3: G = __r_arr[0];
+            let __v_4: G = __r_arr[1];
+            let __ret: [G; OUT_509] = [__v_3, __v_4];
             record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = []; 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_13: G = __r_arr[0];
-            let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_509] = [__v_13, __v_14];
+            let __v_3: G = __r_arr[0];
+            let __v_4: G = __r_arr[1];
+            let __ret: [G; OUT_509] = [__v_3, __v_4];
             record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-        let __v_8: G = __loaded[0];
-        let __v_9: G = __loaded[1];
-        let __v_10: G = __loaded[2];
-        let __v_11: G = __loaded[3];
-        let __v_12: G = __loaded[4];
-        match __v_8.as_canonical_u64() {
-          1u64 => {
+      _ => {
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
             let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_509] = [__v_13, __v_14];
+            let __v_7: G = __r_arr[0];
+            let __v_8: G = __r_arr[1];
+            let __ret: [G; OUT_509] = [__v_7, __v_8];
             record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __v_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            let __v_10: G = __loaded[3];
+            let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_3, __v_4, __v_5, __v_7, __v_8, __v_9, __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_11: G = __r_arr[0];
+            let __v_12: G = __r_arr[1];
+            let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_6, __v_10, __v_2]; 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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_7, __v_12, __v_2]; 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_493] = { let __args: [G; IN_493] = [__v_11, __v_12, __v_13, __v_14]; 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_15: G = __r_arr[0];
             let __v_16: G = __r_arr[1];
-            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_13, __v_14, __v_15, __v_16]; 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_17: G = __r_arr[0];
-            let __v_18: G = __r_arr[1];
-            let __ret: [G; OUT_509] = [__v_17, __v_18];
+            let __ret: [G; OUT_509] = [__v_15, __v_16];
             record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -45240,7 +44696,7 @@ fn aiur_fn_513(
       _ => {
         let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_1, __v_6]; 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];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -45255,7 +44711,7 @@ fn aiur_fn_513(
         let __v_20: G = __loaded[11];
         let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_2, __v_3, __v_6]; 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_21: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_22: G = __loaded[0];
         let __v_23: G = __loaded[1];
         let __v_24: G = __loaded[2];
@@ -45432,23 +44888,15 @@ fn aiur_fn_515(
     let __v_18: G = __r_arr[6];
     let __v_19: G = __r_arr[7];
     let __v_20: G = G::from_u64(0);
-    let __v_21: G = G::from_u64(1);
-    let __v_22: G = G::from_u64(1);
-    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_24: G = G::from_u64(1);
-    let __v_25: G = G::from_u64(1);
-    let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_27: G = G::from_u64(1);
-    let __v_28: G = G::from_u64(1);
-    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_30: G = G::from_u64(1);
-    let __v_31: G = G::from_u64(1);
-    let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
-    let __v_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
-    let __v_34: G = __r_arr[0];
-    let __ret: [G; OUT_515] = [__v_34];
+    let __v_21: G = G::from_u64(0);
+    let __v_22: G = G::from_u64(0);
+    let __v_23: G = G::from_u64(0);
+    let __v_24: G = G::from_u64(0);
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_21, __v_22, __v_23, __v_24]; 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_25: G = __r_arr[0];
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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_26: G = __r_arr[0];
+    let __ret: [G; OUT_515] = [__v_26];
     record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -45466,11 +44914,11 @@ fn aiur_fn_516(
   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_726] = { let __args: [G; IN_726] = [__v_0, __v_1]; 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_727] = { let __args: [G; IN_727] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_2]; 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_3: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -45544,7 +44992,7 @@ fn aiur_fn_518(
     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_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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
@@ -45569,37 +45017,31 @@ fn aiur_fn_519(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_519] = [__v_10];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_519] = [__v_5];
         record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_6, __v_1, __v_2, __v_3, __v_4]; 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_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = (__v_3 + __v_10);
-        let __v_12: G = (__v_4 + __v_9);
-        let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_7, __v_1, __v_2, __v_11, __v_12]; 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 __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_5, __v_1, __v_2, __v_3, __v_4]; 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 __v_8: G = __r_arr[1];
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = (__v_3 + __v_9);
+        let __v_11: G = (__v_4 + __v_8);
+        let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_6, __v_1, __v_2, __v_10, __v_11]; 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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_7, __v_12]; 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_8, __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 __ret: [G; OUT_519] = [__v_14];
+        let __ret: [G; OUT_519] = [__v_13];
         record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
     }
   })
 }
@@ -45619,52 +45061,45 @@ fn aiur_fn_520(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_520] = [__v_10, __v_11];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_520] = [__v_5, __v_6];
         record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_1, __v_6]; 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_10: G = __r_arr[0];
-        let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_2, __v_6, __v_10, __v_4, __v_11]; 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 __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_6, __v_1, __v_2, __v_3, __v_4]; 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 __v_8: G = __r_arr[1];
+        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __v_10: G = G::from_u64(0);
+        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_2, __v_5, __v_9, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_1, __v_5]; 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_12: G = __r_arr[0];
-        let __v_13: G = G::from_u64(0);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_8]; 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_15: G = __r_arr[0];
-        let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_17: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-        match __v_17.as_canonical_u64() {
+        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_11, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_3, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_15: G = { let __a_val = __v_8.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_15.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_520] = [__v_16, __v_10];
+            let __ret: [G; OUT_520] = [__v_14, __v_9];
             record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_520] = [__v_16, __v_9];
+            let __ret: [G; OUT_520] = [__v_14, __v_8];
             record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
     }
   })
 }
@@ -45687,24 +45122,21 @@ fn aiur_fn_521(
     let __v_5: G = (__v_2 - __v_4);
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_521] = [__v_8];
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_521] = [__v_6];
         record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_6: G = G::from_u64(0);
         let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_0, __v_1, __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 __v_7: G = __r_arr[0];
-        let __v_8: G = (__v_3 + __v_4);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = (__v_4 + __v_9);
-        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_521] = [__v_12];
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = (__v_3 + __v_4);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_4 + __v_8);
+        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_1, __v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = { 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_521] = [__v_11];
         record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -45726,17 +45158,14 @@ fn aiur_fn_522(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(0);
-    let __v_4: G = G::from_u64(1);
+    let __v_4: G = { let __values: [G; 2] = [__v_0, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_5: G = G::from_u64(1);
-    let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_8: G = G::from_u64(1);
-    let __r_arr: [G; OUT_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 __v_9: G = __r_arr[0];
-    let __v_10: G = (__v_8 + __v_9);
-    let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_7, __v_1, __v_2, __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 __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_522] = [__v_11];
+    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __v_7: G = (__v_5 + __v_6);
+    let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_4, __v_1, __v_2, __v_7]; 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_8: G = __r_arr[0];
+    let __ret: [G; OUT_522] = [__v_8];
     record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -45764,7 +45193,7 @@ fn aiur_fn_523(
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
@@ -45806,33 +45235,27 @@ fn aiur_fn_524(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_524] = [__v_8];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_524] = [__v_3];
         record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_5, __v_6]; 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_524] = [__v_8];
+        let __ret: [G; OUT_524] = [__v_7];
         record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -45850,24 +45273,19 @@ fn aiur_fn_525(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_525] = [__v_6];
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_525] = [__v_4];
         record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_8: G = { let __values: [G; 3] = [__v_4, __v_0, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_525] = [__v_8];
+        let __v_5: G = { let __values: [G; 2] = [__v_0, __v_4]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_525] = [__v_5];
         record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -45897,31 +45315,25 @@ fn aiur_fn_526(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_526] = [__v_8];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_526] = [__v_3];
         record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_526] = [__v_7];
+        let __ret: [G; OUT_526] = [__v_6];
         record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -45940,73 +45352,64 @@ fn aiur_fn_527(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_11: G = { let __values: [G; 3] = [__v_7, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_527] = [__v_11];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = { let __values: [G; 2] = [__v_0, __v_4]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_527] = [__v_5];
         record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
         let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_3, __v_0]; 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_7: G = __r_arr[0];
-        let __v_8: G = __r_arr[1];
-        let __v_9: G = __r_arr[2];
-        let __v_10: G = __r_arr[3];
-        let __v_11: G = __r_arr[4];
-        let __v_12: G = __r_arr[5];
-        let __v_13: G = __r_arr[6];
-        let __v_14: G = __r_arr[7];
-        let __v_15: G = __r_arr[8];
-        let __v_16: G = __r_arr[9];
-        let __v_17: G = __r_arr[10];
-        let __v_18: G = __r_arr[11];
-        let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_3, __v_5]; 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_19: G = __r_arr[0];
-        let __v_20: G = __r_arr[1];
-        let __v_21: G = __r_arr[2];
-        let __v_22: G = __r_arr[3];
-        let __v_23: G = __r_arr[4];
-        let __v_24: G = __r_arr[5];
-        let __v_25: G = __r_arr[6];
-        let __v_26: G = __r_arr[7];
-        let __v_27: G = __r_arr[8];
-        let __v_28: G = __r_arr[9];
-        let __v_29: G = __r_arr[10];
-        let __v_30: G = __r_arr[11];
-        let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } };
-        let __v_31: G = __r_arr[0];
-        let __v_32: G = __r_arr[1];
-        match __v_31.as_canonical_u64() {
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = __r_arr[2];
+        let __v_9: G = __r_arr[3];
+        let __v_10: G = __r_arr[4];
+        let __v_11: G = __r_arr[5];
+        let __v_12: G = __r_arr[6];
+        let __v_13: G = __r_arr[7];
+        let __v_14: G = __r_arr[8];
+        let __v_15: G = __r_arr[9];
+        let __v_16: G = __r_arr[10];
+        let __v_17: G = __r_arr[11];
+        let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__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_18: G = __r_arr[0];
+        let __v_19: G = __r_arr[1];
+        let __v_20: G = __r_arr[2];
+        let __v_21: G = __r_arr[3];
+        let __v_22: G = __r_arr[4];
+        let __v_23: G = __r_arr[5];
+        let __v_24: G = __r_arr[6];
+        let __v_25: G = __r_arr[7];
+        let __v_26: G = __r_arr[8];
+        let __v_27: G = __r_arr[9];
+        let __v_28: G = __r_arr[10];
+        let __v_29: G = __r_arr[11];
+        let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } };
+        let __v_30: G = __r_arr[0];
+        let __v_31: G = __r_arr[1];
+        match __v_30.as_canonical_u64() {
           0u64 => {
-            let __v_33: G = G::from_u64(0);
-            let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_527] = [__v_34];
+            let __v_32: G = { let __values: [G; 2] = [__v_0, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_527] = [__v_32];
             record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_33: G = G::from_u64(0);
-            let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_0, __v_6, __v_2, __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 __v_34: G = __r_arr[0];
-            let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_527] = [__v_35];
+            let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_0, __v_5, __v_2, __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 __v_32: G = __r_arr[0];
+            let __v_33: G = { let __values: [G; 2] = [__v_4, __v_32]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_527] = [__v_33];
             record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
     }
   })
 }
@@ -46024,33 +45427,24 @@ fn aiur_fn_528(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_528] = [__v_8];
-        record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_5, __v_1, __v_2, __v_4, __v_10]; 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_11: G = __r_arr[0];
-        let __ret: [G; OUT_528] = [__v_11];
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_528] = [__v_3];
         record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = { let __values: [G; 2] = [__v_3, __v_5]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_4, __v_1, __v_2, __v_3, __v_6]; 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_7: G = __r_arr[0];
+        let __ret: [G; OUT_528] = [__v_7];
+        record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -46071,80 +45465,69 @@ fn aiur_fn_529(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_529] = [__v_12];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = { let __values: [G; 2] = [__v_4, __v_5]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_529] = [__v_6];
         record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
         let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        let __v_10: G = __r_arr[2];
-        let __v_11: G = __r_arr[3];
-        let __v_12: G = __r_arr[4];
-        let __v_13: G = __r_arr[5];
-        let __v_14: G = __r_arr[6];
-        let __v_15: G = __r_arr[7];
-        let __v_16: G = __r_arr[8];
-        let __v_17: G = __r_arr[9];
-        let __v_18: G = __r_arr[10];
-        let __v_19: G = __r_arr[11];
-        let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_2, __v_6]; 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_20: G = __r_arr[0];
-        let __v_21: G = __r_arr[1];
-        let __v_22: G = __r_arr[2];
-        let __v_23: G = __r_arr[3];
-        let __v_24: G = __r_arr[4];
-        let __v_25: G = __r_arr[5];
-        let __v_26: G = __r_arr[6];
-        let __v_27: G = __r_arr[7];
-        let __v_28: G = __r_arr[8];
-        let __v_29: G = __r_arr[9];
-        let __v_30: G = __r_arr[10];
-        let __v_31: G = __r_arr[11];
-        let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } };
-        let __v_32: G = __r_arr[0];
-        let __v_33: G = __r_arr[1];
-        match __v_32.as_canonical_u64() {
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = __r_arr[1];
+        let __v_9: G = __r_arr[2];
+        let __v_10: G = __r_arr[3];
+        let __v_11: G = __r_arr[4];
+        let __v_12: G = __r_arr[5];
+        let __v_13: G = __r_arr[6];
+        let __v_14: G = __r_arr[7];
+        let __v_15: G = __r_arr[8];
+        let __v_16: G = __r_arr[9];
+        let __v_17: G = __r_arr[10];
+        let __v_18: G = __r_arr[11];
+        let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_2, __v_5]; 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __v_21: G = __r_arr[2];
+        let __v_22: G = __r_arr[3];
+        let __v_23: G = __r_arr[4];
+        let __v_24: G = __r_arr[5];
+        let __v_25: G = __r_arr[6];
+        let __v_26: G = __r_arr[7];
+        let __v_27: G = __r_arr[8];
+        let __v_28: G = __r_arr[9];
+        let __v_29: G = __r_arr[10];
+        let __v_30: G = __r_arr[11];
+        let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } };
+        let __v_31: G = __r_arr[0];
+        let __v_32: G = __r_arr[1];
+        match __v_31.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4, __v_6]; 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_717] = { let __args: [G; IN_717] = [__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 __v_33: G = __r_arr[0];
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_6, __v_1, __v_2, __v_5, __v_33]; 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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_7, __v_1, __v_2, __v_6, __v_34]; 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_35: G = __r_arr[0];
-            let __ret: [G; OUT_529] = [__v_35];
+            let __ret: [G; OUT_529] = [__v_34];
             record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_34: G = G::from_u64(0);
-            let __v_35: G = G::from_u64(0);
-            let __v_36: G = G::from_u64(1);
-            let __v_37: G = G::from_u64(1);
-            let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
-            let __v_40: G = __r_arr[0];
-            let __v_41: G = { let __values: [G; 3] = [__v_34, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_529] = [__v_41];
+            let __v_33: G = G::from_u64(0);
+            let __v_34: G = { let __values: [G; 2] = [__v_5, __v_33]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_6, __v_1, __v_2, __v_5, __v_34]; 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_35: G = __r_arr[0];
+            let __v_36: G = { let __values: [G; 2] = [__v_4, __v_35]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_529] = [__v_36];
             record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
     }
   })
 }
@@ -46161,70 +45544,58 @@ fn aiur_fn_530(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_530] = [__v_8];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_2: G = G::from_u64(1);
+            let __ret: [G; OUT_530] = [__v_2];
             record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_530] = [__v_8];
+            let __v_2: G = G::from_u64(0);
+            let __ret: [G; OUT_530] = [__v_2];
             record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_530] = [__v_8];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_530] = [__v_4];
             record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            match __v_8.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_4: G = __loaded[0];
+            let __v_5: G = __loaded[1];
+            let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            match __v_6.as_canonical_u64() {
               0u64 => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_530] = [__v_9];
+                let __v_7: G = G::from_u64(0);
+                let __ret: [G; OUT_530] = [__v_7];
                 record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
-                let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_530] = [__v_9];
+                let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_3, __v_5]; 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_7: G = __r_arr[0];
+                let __ret: [G; OUT_530] = [__v_7];
                 record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -46240,31 +45611,25 @@ fn aiur_fn_531(
 ) -> Result<[G; OUT_531], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_531] = [__v_6];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_531] = [__v_1];
         record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_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 __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_1, __v_3]; 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_2, __v_4]; 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_531] = [__v_5];
+        let __ret: [G; OUT_531] = [__v_4];
         record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -46280,39 +45645,35 @@ fn aiur_fn_532(
 ) -> Result<[G; OUT_532], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_532] = [__v_4];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_532] = [__v_1];
         record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_2]; 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_4: G = __r_arr[0];
-        match __v_4.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_1]; 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_3: G = __r_arr[0];
+        match __v_3.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
-            let __v_5: G = __r_arr[0];
-            let __ret: [G; OUT_532] = [__v_5];
+            let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_2]; 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_4: G = __r_arr[0];
+            let __ret: [G; OUT_532] = [__v_4];
             record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_5: G = G::from_u64(0);
-            let __ret: [G; OUT_532] = [__v_5];
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_532] = [__v_4];
             record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -46329,86 +45690,79 @@ fn aiur_fn_533(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: G = __loaded[31];
-    let __v_34: G = __loaded[32];
-    let __v_35: G = __loaded[33];
-    let __v_36: G = __loaded[34];
-    let __v_37: G = __loaded[35];
-    let __v_38: G = __loaded[36];
-    let __v_39: G = __loaded[37];
-    let __v_40: G = __loaded[38];
-    let __v_41: G = __loaded[39];
-    let __v_42: G = __loaded[40];
-    let __v_43: G = __loaded[41];
-    let __v_44: G = __loaded[42];
-    let __v_45: G = __loaded[43];
-    let __v_46: G = __loaded[44];
-    let __v_47: G = __loaded[45];
-    let __v_48: G = __loaded[46];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_49: G = G::from_u64(1);
-        let __v_50: G = G::from_u64(1);
-        let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_533] = [__v_51];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_533] = [__v_2];
         record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_49: G = G::from_u64(1);
-        let __v_50: G = (__v_1 + __v_49);
-        let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_48, __v_50]; 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_51: G = __r_arr[0];
-        match __v_3.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __v_11: G = __loaded[9];
+        let __v_12: G = __loaded[10];
+        let __v_13: G = __loaded[11];
+        let __v_14: G = __loaded[12];
+        let __v_15: G = __loaded[13];
+        let __v_16: G = __loaded[14];
+        let __v_17: G = __loaded[15];
+        let __v_18: G = __loaded[16];
+        let __v_19: G = __loaded[17];
+        let __v_20: G = __loaded[18];
+        let __v_21: G = __loaded[19];
+        let __v_22: G = __loaded[20];
+        let __v_23: G = __loaded[21];
+        let __v_24: G = __loaded[22];
+        let __v_25: G = __loaded[23];
+        let __v_26: G = __loaded[24];
+        let __v_27: G = __loaded[25];
+        let __v_28: G = __loaded[26];
+        let __v_29: G = __loaded[27];
+        let __v_30: G = __loaded[28];
+        let __v_31: G = __loaded[29];
+        let __v_32: G = __loaded[30];
+        let __v_33: G = __loaded[31];
+        let __v_34: G = __loaded[32];
+        let __v_35: G = __loaded[33];
+        let __v_36: G = __loaded[34];
+        let __v_37: G = __loaded[35];
+        let __v_38: G = __loaded[36];
+        let __v_39: G = __loaded[37];
+        let __v_40: G = __loaded[38];
+        let __v_41: G = __loaded[39];
+        let __v_42: G = __loaded[40];
+        let __v_43: G = __loaded[41];
+        let __v_44: G = __loaded[42];
+        let __v_45: G = __loaded[43];
+        let __v_46: G = __loaded[44];
+        let __v_47: G = __loaded[45];
+        let __v_48: G = G::from_u64(1);
+        let __v_49: G = (__v_1 + __v_48);
+        let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_47, __v_49]; 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_50: G = __r_arr[0];
+        match __v_2.as_canonical_u64() {
           1u64 => {
-            let __v_52: G = G::from_u64(0);
-            let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_533] = [__v_53];
+            let __v_51: G = { let __values: [G; 2] = [__v_1, __v_50]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_533] = [__v_51];
             record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_533] = [__v_51];
+            let __ret: [G; OUT_533] = [__v_50];
             record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -46425,100 +45779,96 @@ fn aiur_fn_534(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: G = __loaded[31];
-    let __v_34: G = __loaded[32];
-    let __v_35: G = __loaded[33];
-    let __v_36: G = __loaded[34];
-    let __v_37: G = __loaded[35];
-    let __v_38: G = __loaded[36];
-    let __v_39: G = __loaded[37];
-    let __v_40: G = __loaded[38];
-    let __v_41: G = __loaded[39];
-    let __v_42: G = __loaded[40];
-    let __v_43: G = __loaded[41];
-    let __v_44: G = __loaded[42];
-    let __v_45: G = __loaded[43];
-    let __v_46: G = __loaded[44];
-    let __v_47: G = __loaded[45];
-    let __v_48: G = __loaded[46];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_49: G = G::from_u64(0);
-        let __ret: [G; OUT_534] = [__v_49];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_534] = [__v_2];
         record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __v_11: G = __loaded[9];
+        let __v_12: G = __loaded[10];
+        let __v_13: G = __loaded[11];
+        let __v_14: G = __loaded[12];
+        let __v_15: G = __loaded[13];
+        let __v_16: G = __loaded[14];
+        let __v_17: G = __loaded[15];
+        let __v_18: G = __loaded[16];
+        let __v_19: G = __loaded[17];
+        let __v_20: G = __loaded[18];
+        let __v_21: G = __loaded[19];
+        let __v_22: G = __loaded[20];
+        let __v_23: G = __loaded[21];
+        let __v_24: G = __loaded[22];
+        let __v_25: G = __loaded[23];
+        let __v_26: G = __loaded[24];
+        let __v_27: G = __loaded[25];
+        let __v_28: G = __loaded[26];
+        let __v_29: G = __loaded[27];
+        let __v_30: G = __loaded[28];
+        let __v_31: G = __loaded[29];
+        let __v_32: G = __loaded[30];
+        let __v_33: G = __loaded[31];
+        let __v_34: G = __loaded[32];
+        let __v_35: G = __loaded[33];
+        let __v_36: G = __loaded[34];
+        let __v_37: G = __loaded[35];
+        let __v_38: G = __loaded[36];
+        let __v_39: G = __loaded[37];
+        let __v_40: G = __loaded[38];
+        let __v_41: G = __loaded[39];
+        let __v_42: G = __loaded[40];
+        let __v_43: G = __loaded[41];
+        let __v_44: G = __loaded[42];
+        let __v_45: G = __loaded[43];
+        let __v_46: G = __loaded[44];
+        let __v_47: G = __loaded[45];
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
   0u64 => {
     break '__mc_0 [__v_1];
   },
   1u64 => {
-    let __v_49: G = G::from_u64(1);
-    let __v_50: G = (__v_49 - __v_1);
-    break '__mc_0 [__v_50];
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = (__v_48 - __v_1);
+    break '__mc_0 [__v_49];
   },
   2u64 => {
-    let __v_49: G = G::from_u64(0);
-    break '__mc_0 [__v_49];
+    let __v_48: G = G::from_u64(0);
+    break '__mc_0 [__v_48];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+    return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
   },
 }
  };
-        let __v_49: G = __mc_out___mc_0[0];
-        match __v_49.as_canonical_u64() {
+        let __v_48: G = __mc_out___mc_0[0];
+        match __v_48.as_canonical_u64() {
           1u64 => {
-            let __v_50: G = G::from_u64(1);
-            let __ret: [G; OUT_534] = [__v_50];
+            let __v_49: G = G::from_u64(1);
+            let __ret: [G; OUT_534] = [__v_49];
             record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } };
-            let __v_50: G = __r_arr[0];
-            let __ret: [G; OUT_534] = [__v_50];
+            let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_47, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } };
+            let __v_49: G = __r_arr[0];
+            let __ret: [G; OUT_534] = [__v_49];
             record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -46601,7 +45951,7 @@ fn aiur_fn_535(
             if (__v_55 != __v_56) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("mutual block mixes a definition member with inductives".to_string()) });
             }
-            let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_50]; 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_734] = { let __args: [G; IN_734] = [__v_50]; 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_57: G = __r_arr[0];
             let __v_58: G = G::from_u64(2);
             let __v_59: G = { let __a_val = __v_57.as_canonical_u64(); let __b_val = __v_58.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
@@ -46615,29 +45965,26 @@ fn aiur_fn_535(
                 let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
                 let __v_60: G = __r_arr[0];
                 let __v_61: G = G::from_u64(0);
-                let __v_62: G = G::from_u64(1);
+                let __v_62: G = { let __values: [G; 2] = [__v_50, __v_61]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 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_61, __v_50, __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 = G::from_u64(1);
-                let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_50]; 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_734] = { let __args: [G; IN_734] = [__v_50]; 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_64: G = __r_arr[0];
+                let __v_65: G = (__v_63 + __v_64);
+                let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_62, __v_60, __v_0, __v_65]; 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_66: G = __r_arr[0];
+                let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_66]; 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_67: G = __r_arr[0];
-                let __v_68: G = (__v_66 + __v_67);
-                let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_65, __v_60, __v_0, __v_68]; 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_68: G = G::from_u64(1);
+                if (__v_67 != __v_68) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_68.as_canonical_u64(), msg: Some("canonical block: refinement left members tied, order ambiguous".to_string()) });
+                }
+                let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_66]; 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_69: G = __r_arr[0];
-                let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_69]; 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_313] = { let __args: [G; IN_313] = [__v_69, __v_50]; 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_70: G = __r_arr[0];
                 let __v_71: G = G::from_u64(1);
                 if (__v_70 != __v_71) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: Some("canonical block: refinement left members tied, order ambiguous".to_string()) });
-                }
-                let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_69]; 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_72: G = __r_arr[0];
-                let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_72, __v_50]; 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_73: G = __r_arr[0];
-                let __v_74: G = G::from_u64(1);
-                if (__v_73 != __v_74) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_74.as_canonical_u64(), msg: Some("canonical block: members are not in canonical order".to_string()) });
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: Some("canonical block: members are not in canonical order".to_string()) });
                 }
                 let __ret: [G; OUT_535] = [];
                 record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -46750,7 +46097,7 @@ fn aiur_fn_537(
 ) -> Result<[G; OUT_537], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -46771,7 +46118,7 @@ fn aiur_fn_537(
       2u64 => {
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_2]; 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_5: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -46900,7 +46247,7 @@ fn aiur_fn_539(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -46959,26 +46306,22 @@ fn aiur_fn_540(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_540] = [];
         record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_3, __v_1]; 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_540] = { let __args: [G; IN_540] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } };
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_1]; 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_540] = { let __args: [G; IN_540] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } };
         let __ret: [G; OUT_540] = [];
         record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -46996,7 +46339,7 @@ fn aiur_fn_541(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -47021,7 +46364,7 @@ fn aiur_fn_541(
       2u64 => {
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -47036,7 +46379,7 @@ fn aiur_fn_541(
         let __v_19: G = __loaded[11];
         let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__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[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_5]; 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_734] = { let __args: [G; IN_734] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         if (__v_21 != __v_20) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
@@ -47141,7 +46484,7 @@ fn aiur_fn_542(
     let __v_29: G = G::from_u64(99);
     let __v_30: G = G::from_u64(202);
     let __v_31: G = G::from_u64(184);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_542] = [__v_32];
     record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -47170,7 +46513,7 @@ fn aiur_fn_543(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_4: G = __loaded[0];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -47239,10 +46582,10 @@ fn aiur_fn_544(
     let __v_29: G = G::from_u64(200);
     let __v_30: G = G::from_u64(224);
     let __v_31: G = G::from_u64(201);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_32]; 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_33: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_34: G = __loaded[0];
     let __v_35: G = __loaded[1];
     let __v_36: G = __loaded[2];
@@ -47390,7 +46733,7 @@ fn aiur_fn_546(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
@@ -47429,7 +46772,7 @@ fn aiur_fn_547(
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        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_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = G::from_u64(0);
         if (__v_3 != __v_4) {
@@ -47440,38 +46783,44 @@ fn aiur_fn_547(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_3: G = __loaded[0];
-        let __v_4: G = __loaded[1];
-        let __v_5: G = __loaded[2];
-        match __v_3.as_canonical_u64() {
+        match __v_0.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_6: G = __loaded[0];
-            let __v_7: G = __loaded[1];
-            let __v_8: G = __loaded[2];
-            match __v_6.as_canonical_u64() {
+            let __v_3: G = G::from_u64(0);
+            let __v_4: G = G::from_u64(1);
+            if (__v_3 != __v_4) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_547] = [];
+            record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_3: G = __loaded[0];
+            let __v_4: G = __loaded[1];
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_5: G = __loaded[0];
+            let __v_6: G = __loaded[1];
+            let __v_7: G = __loaded[2];
+            match __v_5.as_canonical_u64() {
               4u64 => {
-                let __v_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_547] = { let __args: [G; IN_547] = [__v_5, __v_10, __v_12]; 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)? } };
-                if (__v_7 != __v_2) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return type: universe level is not Param(i) in order".to_string()) });
+                let __v_8: G = G::from_u64(1);
+                let __v_9: G = (__v_1 - __v_8);
+                let __v_10: G = G::from_u64(1);
+                let __v_11: G = (__v_2 + __v_10);
+                let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_4, __v_9, __v_11]; 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)? } };
+                if (__v_6 != __v_2) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return type: universe level is not Param(i) in order".to_string()) });
                 }
                 let __ret: [G; OUT_547] = [];
                 record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-          },
         }
       },
     }
@@ -47500,41 +46849,47 @@ fn aiur_fn_548(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
+        match __v_0.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-            let __v_8: G = __loaded[0];
-            let __v_9: G = __loaded[1];
-            let __v_10: G = __loaded[2];
-            let __v_11: G = __loaded[3];
-            match __v_8.as_canonical_u64() {
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
+            if (__v_5 != __v_6) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_548] = [];
+            record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_5: G = __loaded[0];
+            let __v_6: G = __loaded[1];
+            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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __v_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            let __v_10: G = __loaded[3];
+            match __v_7.as_canonical_u64() {
               0u64 => {
-                let __v_12: G = G::from_u64(1);
-                let __v_13: G = (__v_3 + __v_12);
-                let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_7, __v_1, __v_2, __v_13]; 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_14: G = (__v_2 + __v_1);
-                let __v_15: G = G::from_u64(1);
-                let __v_16: G = (__v_14 - __v_15);
-                let __v_17: G = (__v_16 - __v_3);
-                if (__v_9 != __v_17) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("ctor return type: param arg is not the expected param BVar".to_string()) });
+                let __v_11: G = G::from_u64(1);
+                let __v_12: G = (__v_3 + __v_11);
+                let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_6, __v_1, __v_2, __v_12]; 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_13: G = (__v_2 + __v_1);
+                let __v_14: G = G::from_u64(1);
+                let __v_15: G = (__v_13 - __v_14);
+                let __v_16: G = (__v_15 - __v_3);
+                if (__v_8 != __v_16) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("ctor return type: param arg is not the expected param BVar".to_string()) });
                 }
                 let __ret: [G; OUT_548] = [];
                 record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
     }
@@ -47556,7 +46911,7 @@ fn aiur_fn_549(
     let __v_2: G = inp[2];
     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; 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_3: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -47614,7 +46969,7 @@ fn aiur_fn_550(
     let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_8]; 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_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_11: G = __loaded[0];
     let __v_12: G = __loaded[1];
     let __v_13: G = __loaded[2];
@@ -47626,24 +46981,21 @@ fn aiur_fn_550(
         let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } };
         let __v_16: G = G::from_u64(0);
         let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_10, __v_1, __v_3, __v_16]; 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_735] = { let __args: [G; IN_735] = [__v_10, __v_1]; 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_736] = { let __args: [G; IN_736] = [__v_10, __v_1]; 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_17: G = __r_arr[0];
         let __v_18: G = G::from_u64(0);
-        let __v_19: G = G::from_u64(1);
-        let __v_20: G = G::from_u64(1);
-        let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_10]; 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_23: G = __r_arr[0];
-        let __v_24: G = (__v_1 + __v_2);
-        if (__v_23 != __v_24) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("ctor return type: wrong number of spine arguments".to_string()) });
+        let __v_19: G = { let __values: [G; 2] = [__v_5, __v_18]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_10]; 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_20: G = __r_arr[0];
+        let __v_21: G = (__v_1 + __v_2);
+        if (__v_20 != __v_21) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("ctor return type: wrong number of spine arguments".to_string()) });
         }
-        let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_17, __v_22]; 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_25: G = __r_arr[0];
-        let __v_26: G = G::from_u64(0);
-        if (__v_25 != __v_26) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("ctor return type: reflexive occurrence in an index argument".to_string()) });
+        let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_17, __v_19]; 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_22: G = __r_arr[0];
+        let __v_23: G = G::from_u64(0);
+        if (__v_22 != __v_23) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("ctor return type: reflexive occurrence in an index argument".to_string()) });
         }
         let __ret: [G; OUT_550] = [];
         record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -47677,14 +47029,14 @@ fn aiur_fn_551(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_4: G = __loaded[0];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
         let __v_7: G = __loaded[3];
         match __v_4.as_canonical_u64() {
           5u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_8: G = __loaded[0];
             let __v_9: G = __loaded[1];
             let __v_10: G = __loaded[2];
@@ -47693,15 +47045,14 @@ fn aiur_fn_551(
               5u64 => {
                 let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_5, __v_9, __v_3]; 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(0);
-                let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_15: G = G::from_u64(1);
-                if (__v_12 != __v_15) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("ctor parameter type disagrees with the inductive's".to_string()) });
+                let __v_13: G = { let __values: [G; 2] = [__v_5, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_14: G = G::from_u64(1);
+                if (__v_12 != __v_14) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("ctor parameter type disagrees with the inductive's".to_string()) });
                 }
-                let __v_16: G = G::from_u64(1);
-                let __v_17: G = (__v_2 - __v_16);
-                let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } };
+                let __v_15: G = G::from_u64(1);
+                let __v_16: G = (__v_2 - __v_15);
+                let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_6, __v_10, __v_16, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } };
                 let __ret: [G; OUT_551] = [];
                 record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -47733,10 +47084,8 @@ fn aiur_fn_552(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __v_3: G = G::from_u64(1);
-    let __v_4: G = G::from_u64(1);
-    let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_0, __v_1, __v_2, __v_5]; 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_3: G = G::from_u64(0);
+    let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } };
     let __ret: [G; OUT_552] = [];
     record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -47760,7 +47109,7 @@ fn aiur_fn_553(
     let __v_3: G = __r_arr[0];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_4: G = __loaded[0];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -47777,7 +47126,7 @@ fn aiur_fn_553(
         }
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_4: G = __loaded[0];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -47786,11 +47135,10 @@ fn aiur_fn_553(
           5u64 => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_1 - __v_8);
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_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_553] = { let __args: [G; IN_553] = [__v_6, __v_9, __v_11]; 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_12: G = __r_arr[0];
-            let __ret: [G; OUT_553] = [__v_12];
+            let __v_10: G = { let __values: [G; 2] = [__v_5, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_6, __v_9, __v_10]; 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_11: G = __r_arr[0];
+            let __ret: [G; OUT_553] = [__v_11];
             record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -47816,7 +47164,7 @@ fn aiur_fn_554(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -47831,9 +47179,8 @@ fn aiur_fn_554(
         if (__v_8 != __v_9) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("ctor field lives in a universe above the inductive's".to_string()) });
         }
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = { let __values: [G; 2] = [__v_4, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } };
         let __ret: [G; OUT_554] = [];
         record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -47869,7 +47216,7 @@ fn aiur_fn_555(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_4: G = __loaded[0];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -47878,9 +47225,8 @@ fn aiur_fn_555(
           5u64 => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_1 - __v_8);
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = { let __values: [G; 2] = [__v_5, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_6, __v_9, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
             let __ret: [G; OUT_555] = [];
             record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -47907,7 +47253,7 @@ fn aiur_fn_556(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -47918,10 +47264,8 @@ fn aiur_fn_556(
         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_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __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 __v_6: G = G::from_u64(0);
+        let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
         let __ret: [G; OUT_556] = [];
         record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -47962,39 +47306,35 @@ fn aiur_fn_558(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_558] = [__v_5];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_558] = [__v_2];
         record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        match __v_5.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        match __v_4.as_canonical_u64() {
           1u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_558] = [__v_6];
+            let __v_5: G = G::from_u64(1);
+            let __ret: [G; OUT_558] = [__v_5];
             record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_558] = [__v_6];
+            let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_3, __v_1]; 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_5: G = __r_arr[0];
+            let __ret: [G; OUT_558] = [__v_5];
             record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -48013,7 +47353,7 @@ fn aiur_fn_559(
     let __v_1: G = inp[1];
     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; 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_2: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -48056,7 +47396,7 @@ fn aiur_fn_560(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -48201,39 +47541,35 @@ fn aiur_fn_561(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_561] = [__v_5];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_561] = [__v_2];
         record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_3, __v_1]; 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_5: G = __r_arr[0];
-        match __v_5.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_2, __v_1]; 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];
+        match __v_4.as_canonical_u64() {
           1u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_561] = [__v_6];
+            let __v_5: G = G::from_u64(1);
+            let __ret: [G; OUT_561] = [__v_5];
             record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_561] = [__v_6];
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } };
+            let __v_5: G = __r_arr[0];
+            let __ret: [G; OUT_561] = [__v_5];
             record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -48258,21 +47594,20 @@ fn aiur_fn_562(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_3: G = __loaded[0];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
         let __v_6: G = __loaded[3];
         match __v_3.as_canonical_u64() {
           5u64 => {
-            let __v_7: G = G::from_u64(0);
-            let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = (__v_1 - __v_9);
-            let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_5, __v_10, __v_8]; 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_11: G = __r_arr[0];
-            let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_562] = [__v_11, __v_12];
+            let __v_7: G = { let __values: [G; 2] = [__v_4, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = (__v_1 - __v_8);
+            let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_5, __v_9, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __v_11: G = __r_arr[1];
+            let __ret: [G; OUT_562] = [__v_10, __v_11];
             record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -48309,40 +47644,46 @@ fn aiur_fn_563(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
+        match __v_0.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-            let __v_8: G = __loaded[0];
-            let __v_9: G = __loaded[1];
-            let __v_10: G = __loaded[2];
-            let __v_11: G = __loaded[3];
-            match __v_8.as_canonical_u64() {
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
+            if (__v_5 != __v_6) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_563] = [];
+            record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_5: G = __loaded[0];
+            let __v_6: G = __loaded[1];
+            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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __v_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            let __v_10: G = __loaded[3];
+            match __v_7.as_canonical_u64() {
               0u64 => {
-                let __v_12: G = G::from_u64(1);
-                let __v_13: G = (__v_2 - __v_12);
-                let __v_14: G = (__v_13 - __v_3);
-                if (__v_9 != __v_14) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("recursive occurrence: parameter arg is not the parameter binder".to_string()) });
+                let __v_11: G = G::from_u64(1);
+                let __v_12: G = (__v_2 - __v_11);
+                let __v_13: G = (__v_12 - __v_3);
+                if (__v_8 != __v_13) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("recursive occurrence: parameter arg is not the parameter binder".to_string()) });
                 }
-                let __v_15: G = G::from_u64(1);
-                let __v_16: G = (__v_3 + __v_15);
-                let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_7, __v_1, __v_2, __v_16]; 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 = G::from_u64(1);
+                let __v_15: G = (__v_3 + __v_14);
+                let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_6, __v_1, __v_2, __v_15]; 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 __ret: [G; OUT_563] = [];
                 record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
     }
@@ -48366,7 +47707,7 @@ fn aiur_fn_564(
     let __v_4: G = inp[4];
     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; 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_5: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_6: G = __loaded[0];
     let __v_7: G = __loaded[1];
     let __v_8: G = __loaded[2];
@@ -48385,13 +47726,13 @@ fn aiur_fn_564(
         let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } };
         let __v_19: G = G::from_u64(0);
         let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_2, __v_9, __v_4, __v_19]; 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_724] = { let __args: [G; IN_724] = [__v_2]; 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_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 __v_20: G = __r_arr[0];
         let __v_21: G = (__v_9 + __v_10);
         if (__v_20 != __v_21) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("recursive occurrence is not fully applied".to_string()) });
         }
-        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2, __v_9]; 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_736] = { let __args: [G; IN_736] = [__v_2, __v_9]; 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_22: G = __r_arr[0];
         let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_22, __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_23: G = __r_arr[0];
@@ -48435,22 +47776,21 @@ fn aiur_fn_565(
       _ => {
         let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
         let __v_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           5u64 => {
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_10: G = { let __values: [G; 2] = [__v_7, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_7, __v_1]; 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_12: G = __r_arr[0];
-            let __v_13: G = G::from_u64(0);
-            if (__v_12 != __v_13) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("strict positivity: block occurs left of an arrow".to_string()) });
+            let __v_11: G = __r_arr[0];
+            let __v_12: G = G::from_u64(0);
+            if (__v_11 != __v_12) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("strict positivity: block occurs left of an arrow".to_string()) });
             }
-            let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_8, __v_1, __v_10, __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 __ret: [G; OUT_565] = [];
             record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -48459,7 +47799,7 @@ fn aiur_fn_565(
             let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_12: G = __loaded[0];
             let __v_13: G = __loaded[1];
             let __v_14: G = __loaded[2];
@@ -48472,7 +47812,7 @@ fn aiur_fn_565(
                   1u64 => {
                     match __v_3.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_2]; 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_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 __v_17: G = __r_arr[0];
                         let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_13, __v_14, __v_11, __v_1, __v_17]; 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 __ret: [G; OUT_565] = [];
@@ -48489,7 +47829,7 @@ fn aiur_fn_565(
                   _ => {
                     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_13]; 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_17: G = __r_arr[0];
-                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                     let __v_18: G = __loaded[0];
                     let __v_19: G = __loaded[1];
                     let __v_20: G = __loaded[2];
@@ -48504,22 +47844,21 @@ fn aiur_fn_565(
                     let __v_29: G = __loaded[11];
                     match __v_18.as_canonical_u64() {
                       5u64 => {
-                        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_11, __v_21]; 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_736] = { let __args: [G; IN_736] = [__v_11, __v_21]; 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_30: G = __r_arr[0];
-                        let __v_31: G = G::from_u64(0);
-                        let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __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_734] = { let __args: [G; IN_734] = [__v_11, __v_21]; 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_31: G = { let __values: [G; 2] = [__v_25, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_11, __v_21]; 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_32: G = __r_arr[0];
+                        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_32]; 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_33: G = __r_arr[0];
-                        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
-                        let __v_34: G = __r_arr[0];
                         let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } };
-                        let __v_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(), msg: Some("strict positivity: block occurs in a nested inductive's index args".to_string()) });
+                        let __v_34: G = __r_arr[0];
+                        let __v_35: G = G::from_u64(0);
+                        if (__v_34 != __v_35) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("strict positivity: block occurs in a nested inductive's index args".to_string()) });
                         }
-                        let __v_37: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; 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_36: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_25, __v_26, __v_23, __v_31, __v_36, __v_21, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } };
                         let __ret: [G; OUT_565] = [];
                         record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
@@ -48569,7 +47908,7 @@ fn aiur_fn_566(
       _ => {
         let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_1, __v_4]; 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];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -48584,23 +47923,19 @@ fn aiur_fn_566(
         let __v_20: G = __loaded[11];
         match __v_9.as_canonical_u64() {
           6u64 => {
-            let __v_21: G = G::from_u64(1);
-            let __v_22: G = G::from_u64(1);
-            let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_11, __v_5, __v_23]; 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_24: G = __r_arr[0];
-            let __v_25: G = __r_arr[1];
+            let __v_21: G = G::from_u64(0);
+            let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_11, __v_5, __v_21]; 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_22: G = __r_arr[0];
+            let __v_23: G = __r_arr[1];
+            let __v_24: G = G::from_u64(0);
+            let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_22, __v_6, __v_24]; 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_25: G = __r_arr[0];
             let __v_26: G = G::from_u64(0);
-            let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_24, __v_6, __v_26]; 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_27: G = __r_arr[0];
+            let __v_27: G = G::from_u64(0);
+            let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_25, __v_3, __v_26, __v_27]; 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_28: G = G::from_u64(1);
-            let __v_29: G = G::from_u64(1);
-            let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_31: G = G::from_u64(0);
-            let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_27, __v_3, __v_30, __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 __v_32: G = G::from_u64(1);
-            let __v_33: G = (__v_4 + __v_32);
-            let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; 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_29: G = (__v_4 + __v_28);
+            let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_1, __v_2, __v_3, __v_29, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } };
             let __ret: [G; OUT_566] = [];
             record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -48628,7 +47963,7 @@ fn aiur_fn_567(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -48636,9 +47971,8 @@ fn aiur_fn_567(
     match __v_4.as_canonical_u64() {
       5u64 => {
         let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_5, __v_1, __v_2, __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_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_6, __v_1, __v_9, __v_3]; 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_8: G = { let __values: [G; 2] = [__v_5, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_6, __v_1, __v_8, __v_3]; 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 __ret: [G; OUT_567] = [];
         record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -48667,15 +48001,12 @@ fn aiur_fn_568(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = G::from_u64(0);
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = G::from_u64(1);
-    let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_5: G = { let __values: [G; 2] = [__v_2, __v_4]; 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() + 1); __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_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __v_10: G = __r_arr[1];
-    let __v_11: G = G::from_u64(1);
-    let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_9, __v_8, __v_10, __v_11]; 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_6: G = __r_arr[0];
+    let __v_7: G = __r_arr[1];
+    let __v_8: G = G::from_u64(1);
+    let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_6, __v_5, __v_7, __v_8]; 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 __ret: [G; OUT_568] = [];
     record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -48700,13 +48031,11 @@ fn aiur_fn_569(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = (__v_1 + __v_2);
-    let __v_8: G = G::from_u64(1);
-    let __v_9: G = G::from_u64(1);
-    let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_0, __v_7, __v_10]; 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_11: G = __r_arr[0];
-    let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = G::from_u64(0);
+    let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_0, __v_7, __v_8]; 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 = G::from_u64(0);
+    let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_9, __v_10]; 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 __ret: [G; OUT_569] = [];
     record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -48742,7 +48071,7 @@ fn aiur_fn_570(
       _ => {
         let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_5, __v_6, __v_8]; 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_10: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_11: G = __loaded[0];
         let __v_12: G = __loaded[1];
         let __v_13: G = __loaded[2];
@@ -48760,15 +48089,13 @@ fn aiur_fn_570(
             let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } };
             let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_13, __v_17, __v_2, __v_18, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } };
             let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_13, __v_17, __v_7]; 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_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_568] = { let __args: [G; IN_568] = [__v_13, __v_17, __v_5, __v_25]; 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_23: G = G::from_u64(0);
+            let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_13, __v_17, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } };
             let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_14, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __v_27: G = G::from_u64(1);
-            if (__v_26 != __v_27) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("ctor belongs to a different block than its inductive".to_string()) });
+            let __v_24: G = __r_arr[0];
+            let __v_25: G = G::from_u64(1);
+            if (__v_24 != __v_25) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("ctor belongs to a different block than its inductive".to_string()) });
             }
             if (__v_15 != __v_6) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("ctor points at a different member of the block".to_string()) });
@@ -48779,9 +48106,9 @@ fn aiur_fn_570(
             if (__v_17 != __v_1) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("ctor parameter count differs from the inductive's".to_string()) });
             }
-            let __v_28: G = G::from_u64(1);
-            let __v_29: G = (__v_8 + __v_28);
-            let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_26: G = G::from_u64(1);
+            let __v_27: G = (__v_8 + __v_26);
+            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_27]; 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 __ret: [G; OUT_570] = [];
             record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -48963,125 +48290,120 @@ fn aiur_fn_573(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_7: G = __loaded[0];
-    let __v_8: G = __loaded[1];
-    let __v_9: G = __loaded[2];
-    let __v_10: G = __loaded[3];
-    let __v_11: G = __loaded[4];
-    let __v_12: G = __loaded[5];
-    let __v_13: G = __loaded[6];
-    let __v_14: G = __loaded[7];
-    let __v_15: G = __loaded[8];
-    let __v_16: G = __loaded[9];
-    let __v_17: G = __loaded[10];
-    let __v_18: G = __loaded[11];
-    let __v_19: G = __loaded[12];
-    let __v_20: G = __loaded[13];
-    let __v_21: G = __loaded[14];
-    let __v_22: G = __loaded[15];
-    let __v_23: G = __loaded[16];
-    let __v_24: G = __loaded[17];
-    let __v_25: G = __loaded[18];
-    let __v_26: G = __loaded[19];
-    let __v_27: G = __loaded[20];
-    let __v_28: G = __loaded[21];
-    let __v_29: G = __loaded[22];
-    let __v_30: G = __loaded[23];
-    let __v_31: G = __loaded[24];
-    let __v_32: G = __loaded[25];
-    let __v_33: G = __loaded[26];
-    let __v_34: G = __loaded[27];
-    let __v_35: G = __loaded[28];
-    let __v_36: G = __loaded[29];
-    let __v_37: G = __loaded[30];
-    let __v_38: G = __loaded[31];
-    let __v_39: G = __loaded[32];
-    let __v_40: G = __loaded[33];
-    let __v_41: G = __loaded[34];
-    let __v_42: G = __loaded[35];
-    let __v_43: G = __loaded[36];
-    let __v_44: G = __loaded[37];
-    let __v_45: G = __loaded[38];
-    let __v_46: G = __loaded[39];
-    let __v_47: G = __loaded[40];
-    let __v_48: G = __loaded[41];
-    let __v_49: G = __loaded[42];
-    let __v_50: G = __loaded[43];
-    let __v_51: G = __loaded[44];
-    let __v_52: G = __loaded[45];
-    let __v_53: G = __loaded[46];
-    match __v_7.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_573] = [];
         record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_8.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __v_12: G = __loaded[5];
+        let __v_13: G = __loaded[6];
+        let __v_14: G = __loaded[7];
+        let __v_15: G = __loaded[8];
+        let __v_16: G = __loaded[9];
+        let __v_17: G = __loaded[10];
+        let __v_18: G = __loaded[11];
+        let __v_19: G = __loaded[12];
+        let __v_20: G = __loaded[13];
+        let __v_21: G = __loaded[14];
+        let __v_22: G = __loaded[15];
+        let __v_23: G = __loaded[16];
+        let __v_24: G = __loaded[17];
+        let __v_25: G = __loaded[18];
+        let __v_26: G = __loaded[19];
+        let __v_27: G = __loaded[20];
+        let __v_28: G = __loaded[21];
+        let __v_29: G = __loaded[22];
+        let __v_30: G = __loaded[23];
+        let __v_31: G = __loaded[24];
+        let __v_32: G = __loaded[25];
+        let __v_33: G = __loaded[26];
+        let __v_34: G = __loaded[27];
+        let __v_35: G = __loaded[28];
+        let __v_36: G = __loaded[29];
+        let __v_37: G = __loaded[30];
+        let __v_38: G = __loaded[31];
+        let __v_39: G = __loaded[32];
+        let __v_40: G = __loaded[33];
+        let __v_41: G = __loaded[34];
+        let __v_42: G = __loaded[35];
+        let __v_43: G = __loaded[36];
+        let __v_44: G = __loaded[37];
+        let __v_45: G = __loaded[38];
+        let __v_46: G = __loaded[39];
+        let __v_47: G = __loaded[40];
+        let __v_48: G = __loaded[41];
+        let __v_49: G = __loaded[42];
+        let __v_50: G = __loaded[43];
+        let __v_51: G = __loaded[44];
+        let __v_52: G = __loaded[45];
+        match __v_7.as_canonical_u64() {
           1u64 => {
-            let __v_54: G = (__v_5 - __v_4);
-            let __v_55: G = G::from_bool((__v_54 == G::ZERO));
-            match __v_55.as_canonical_u64() {
+            let __v_53: G = (__v_5 - __v_4);
+            let __v_54: G = G::from_bool((__v_53 == G::ZERO));
+            match __v_54.as_canonical_u64() {
               1u64 => {
-                let __v_56: G = G::from_u64(1);
-                let __v_57: G = (__v_5 + __v_56);
-                let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; 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_55: G = G::from_u64(1);
+                let __v_56: G = (__v_5 + __v_55);
+                let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_52, __v_1, __v_2, __v_3, __v_4, __v_56, __v_6]; 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 __ret: [G; OUT_573] = [];
                 record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_6, __v_5]; 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_56: G = __r_arr[0];
-                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-                let __v_57: G = __loaded[0];
-                let __v_58: G = __loaded[1];
-                let __v_59: G = __loaded[2];
-                let __v_60: G = __loaded[3];
-                let __v_61: G = __loaded[4];
-                let __v_62: G = __loaded[5];
-                let __v_63: G = __loaded[6];
-                let __v_64: G = __loaded[7];
-                let __v_65: G = __loaded[8];
-                let __v_66: G = __loaded[9];
-                let __v_67: G = __loaded[10];
-                let __v_68: G = __loaded[11];
-                match __v_57.as_canonical_u64() {
+                let __v_55: G = __r_arr[0];
+                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                let __v_56: G = __loaded[0];
+                let __v_57: G = __loaded[1];
+                let __v_58: G = __loaded[2];
+                let __v_59: G = __loaded[3];
+                let __v_60: G = __loaded[4];
+                let __v_61: G = __loaded[5];
+                let __v_62: G = __loaded[6];
+                let __v_63: G = __loaded[7];
+                let __v_64: G = __loaded[8];
+                let __v_65: G = __loaded[9];
+                let __v_66: G = __loaded[10];
+                let __v_67: G = __loaded[11];
+                match __v_56.as_canonical_u64() {
                   5u64 => {
-                    let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } };
-                    let __v_69: G = (__v_2 + __v_3);
-                    let __v_70: G = G::from_u64(1);
-                    let __v_71: G = G::from_u64(1);
-                    let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_1, __v_69, __v_72]; 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_552] = { let __args: [G; IN_552] = [__v_1, __v_58, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } };
+                    let __v_68: G = (__v_2 + __v_3);
+                    let __v_69: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_1, __v_68, __v_69]; 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_70: G = __r_arr[0];
+                    let __v_71: G = (__v_59 + __v_60);
+                    let __v_72: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_58, __v_71, __v_72]; 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_73: G = __r_arr[0];
-                    let __v_74: G = (__v_60 + __v_61);
-                    let __v_75: G = G::from_u64(1);
-                    let __v_76: G = G::from_u64(1);
-                    let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_59, __v_74, __v_77]; 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_78: G = __r_arr[0];
-                    if (__v_60 != __v_2) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) });
+                    if (__v_59 != __v_2) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) });
                     }
-                    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_73, __v_78]; 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_79: G = __r_arr[0];
-                    let __v_80: G = G::from_u64(1);
-                    if (__v_79 != __v_80) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_80.as_canonical_u64(), msg: Some("mutual block peers land in different universes".to_string()) });
+                    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_70, __v_73]; 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_74: G = __r_arr[0];
+                    let __v_75: G = G::from_u64(1);
+                    if (__v_74 != __v_75) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: Some("mutual block peers land in different universes".to_string()) });
                     }
-                    let __v_81: G = G::from_u64(1);
-                    let __v_82: G = (__v_5 + __v_81);
-                    let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; 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_76: G = G::from_u64(1);
+                    let __v_77: G = (__v_5 + __v_76);
+                    let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_52, __v_1, __v_2, __v_3, __v_4, __v_77, __v_6]; 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 __ret: [G; OUT_573] = [];
                     record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __v_69: G = G::from_u64(1);
-                    let __v_70: G = (__v_5 + __v_69);
-                    let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
+                    let __v_68: G = G::from_u64(1);
+                    let __v_69: G = (__v_5 + __v_68);
+                    let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_52, __v_1, __v_2, __v_3, __v_4, __v_69, __v_6]; 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 __ret: [G; OUT_573] = [];
                     record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -49091,18 +48413,15 @@ fn aiur_fn_573(
             }
           },
           _ => {
-            let __v_54: G = G::from_u64(1);
-            let __v_55: G = (__v_5 + __v_54);
-            let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; 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_53: G = G::from_u64(1);
+            let __v_54: G = (__v_5 + __v_53);
+            let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_52, __v_1, __v_2, __v_3, __v_4, __v_54, __v_6]; 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 __ret: [G; OUT_573] = [];
             record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-      },
     }
   })
 }
@@ -49168,12 +48487,10 @@ fn aiur_fn_574(
                         return Ok(__ret);
                       },
                       _ => {
-                        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_575] = { let __args: [G; IN_575] = [__v_5, __v_9, __v_10, __v_18]; 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_19: G = __r_arr[0];
-                        let __ret: [G; OUT_574] = [__v_19];
+                        let __v_16: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_5, __v_9, __v_10, __v_16]; 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_17: G = __r_arr[0];
+                        let __ret: [G; OUT_574] = [__v_17];
                         record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
@@ -49218,30 +48535,27 @@ fn aiur_fn_575(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_575] = [__v_8];
+        let __v_5: G = G::from_u64(0);
+        let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_2, __v_4, __v_3, __v_5]; 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 __ret: [G; OUT_575] = [__v_6];
         record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_4: G = __loaded[0];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
         let __v_7: G = __loaded[3];
         match __v_4.as_canonical_u64() {
           5u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_10: G = G::from_u64(1);
-            let __v_11: G = (__v_1 - __v_10);
-            let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_6, __v_11, __v_2, __v_9]; 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_12: G = __r_arr[0];
-            let __ret: [G; OUT_575] = [__v_12];
+            let __v_8: G = { let __values: [G; 2] = [__v_5, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __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_575] = { let __args: [G; IN_575] = [__v_6, __v_10, __v_2, __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_11: G = __r_arr[0];
+            let __ret: [G; OUT_575] = [__v_11];
             record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -49285,7 +48599,7 @@ fn aiur_fn_576(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -49297,7 +48611,7 @@ fn aiur_fn_576(
             let __v_11: G = G::from_u64(1);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_10, __v_14]; 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_15: G = __r_arr[0];
             let __v_16: G = (__v_11 - __v_15);
@@ -49309,20 +48623,18 @@ fn aiur_fn_576(
     break '__mc_0 [__v_4];
   },
   _ => {
-    let __v_20: G = G::from_u64(0);
-    let __v_21: G = { let __values: [G; 3] = [__v_20, __v_19, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    break '__mc_0 [__v_21];
+    let __v_20: G = { let __values: [G; 2] = [__v_19, __v_4]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    break '__mc_0 [__v_20];
   },
 }
  };
             let __v_20: G = __mc_out___mc_0[0];
-            let __v_21: G = G::from_u64(0);
-            let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_23: G = G::from_u64(1);
-            let __v_24: G = (__v_2 + __v_23);
-            let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_8, __v_1, __v_24, __v_22, __v_20]; 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_25: G = __r_arr[0];
-            let __ret: [G; OUT_576] = [__v_25];
+            let __v_21: G = { let __values: [G; 2] = [__v_7, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_22: G = G::from_u64(1);
+            let __v_23: G = (__v_2 + __v_22);
+            let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_8, __v_1, __v_23, __v_21, __v_20]; 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_24: G = __r_arr[0];
+            let __ret: [G; OUT_576] = [__v_24];
             record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -49350,39 +48662,35 @@ fn aiur_fn_577(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_577] = [__v_5];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_577] = [__v_2];
         record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_1, __v_3]; 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_5: G = __r_arr[0];
-        match __v_5.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        match __v_4.as_canonical_u64() {
           0u64 => {
-            let __v_6: G = G::from_u64(0);
-            let __ret: [G; OUT_577] = [__v_6];
+            let __v_5: G = G::from_u64(0);
+            let __ret: [G; OUT_577] = [__v_5];
             record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1]; 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_577] = [__v_6];
+            let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_1]; 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_5: G = __r_arr[0];
+            let __ret: [G; OUT_577] = [__v_5];
             record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -49399,54 +48707,50 @@ fn aiur_fn_578(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_578] = [__v_5];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_578] = [__v_2];
         record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        let __v_8: G = __loaded[3];
-        match __v_5.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        match __v_4.as_canonical_u64() {
           0u64 => {
-            let __v_9: G = (__v_6 - __v_1);
-            match __v_9.as_canonical_u64() {
+            let __v_8: G = (__v_5 - __v_1);
+            match __v_8.as_canonical_u64() {
               0u64 => {
-                let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_578] = [__v_10];
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_578] = [__v_9];
                 record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_1]; 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_10: G = __r_arr[0];
-                let __ret: [G; OUT_578] = [__v_10];
+                let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __ret: [G; OUT_578] = [__v_9];
                 record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_578] = [__v_9];
+            let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __ret: [G; OUT_578] = [__v_8];
             record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -49487,60 +48791,58 @@ fn aiur_fn_579(
           },
           _ => {
             let __v_14: G = (__v_3 + __v_4);
-            let __v_15: G = G::from_u64(1);
-            let __v_16: G = G::from_u64(1);
-            let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_2, __v_14, __v_17]; 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_18: G = __r_arr[0];
-            let __v_19: G = G::from_u64(0);
-            let __v_20: G = G::from_u64(0);
-            let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_18, __v_21]; 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_22: G = __r_arr[0];
-            match __v_22.as_canonical_u64() {
+            let __v_15: G = G::from_u64(0);
+            let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_2, __v_14, __v_15]; 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_16: G = __r_arr[0];
+            let __v_17: G = G::from_u64(0);
+            let __v_18: G = G::from_u64(0);
+            let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_16, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            match __v_20.as_canonical_u64() {
               0u64 => {
-                let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_579] = [__v_23];
+                let __v_21: G = G::from_u64(0);
+                let __ret: [G; OUT_579] = [__v_21];
                 record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 match __v_5.as_canonical_u64() {
                   1u64 => {
-                    let __v_23: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_7, __v_8, __v_23]; 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_24: G = __r_arr[0];
-                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-                    let __v_25: G = __loaded[0];
-                    let __v_26: G = __loaded[1];
-                    let __v_27: G = __loaded[2];
-                    let __v_28: G = __loaded[3];
-                    let __v_29: G = __loaded[4];
-                    let __v_30: G = __loaded[5];
-                    let __v_31: G = __loaded[6];
-                    let __v_32: G = __loaded[7];
-                    let __v_33: G = __loaded[8];
-                    let __v_34: G = __loaded[9];
-                    let __v_35: G = __loaded[10];
-                    let __v_36: G = __loaded[11];
-                    match __v_25.as_canonical_u64() {
+                    let __v_21: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_7, __v_8, __v_21]; 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_22: G = __r_arr[0];
+                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                    let __v_23: G = __loaded[0];
+                    let __v_24: G = __loaded[1];
+                    let __v_25: G = __loaded[2];
+                    let __v_26: G = __loaded[3];
+                    let __v_27: G = __loaded[4];
+                    let __v_28: G = __loaded[5];
+                    let __v_29: G = __loaded[6];
+                    let __v_30: G = __loaded[7];
+                    let __v_31: G = __loaded[8];
+                    let __v_32: G = __loaded[9];
+                    let __v_33: G = __loaded[10];
+                    let __v_34: G = __loaded[11];
+                    match __v_23.as_canonical_u64() {
                       6u64 => {
-                        let __v_37: G = G::from_bool((__v_32 == G::ZERO));
-                        let __ret: [G; OUT_579] = [__v_37];
+                        let __v_35: G = G::from_bool((__v_30 == G::ZERO));
+                        let __ret: [G; OUT_579] = [__v_35];
                         record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
-                        let __v_37: G = G::from_u64(0);
-                        let __ret: [G; OUT_579] = [__v_37];
+                        let __v_35: G = G::from_u64(0);
+                        let __ret: [G; OUT_579] = [__v_35];
                         record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __v_23: G = G::from_u64(0);
-                    let __ret: [G; OUT_579] = [__v_23];
+                    let __v_21: G = G::from_u64(0);
+                    let __ret: [G; OUT_579] = [__v_21];
                     record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
@@ -49749,94 +49051,90 @@ fn aiur_fn_582(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: G = __loaded[31];
-    let __v_34: G = __loaded[32];
-    let __v_35: G = __loaded[33];
-    let __v_36: G = __loaded[34];
-    let __v_37: G = __loaded[35];
-    let __v_38: G = __loaded[36];
-    let __v_39: G = __loaded[37];
-    let __v_40: G = __loaded[38];
-    let __v_41: G = __loaded[39];
-    let __v_42: G = __loaded[40];
-    let __v_43: G = __loaded[41];
-    let __v_44: G = __loaded[42];
-    let __v_45: G = __loaded[43];
-    let __v_46: G = __loaded[44];
-    let __v_47: G = __loaded[45];
-    let __v_48: G = __loaded[46];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         match __v_1.as_canonical_u64() {
           1u64 => {
-            let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_582] = [__v_49];
+            let __v_2: G = G::from_u64(1);
+            let __ret: [G; OUT_582] = [__v_2];
             record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_49: G = G::from_u64(0);
-            let __ret: [G; OUT_582] = [__v_49];
+            let __v_2: G = G::from_u64(0);
+            let __ret: [G; OUT_582] = [__v_2];
             record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        match __v_3.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __v_11: G = __loaded[9];
+        let __v_12: G = __loaded[10];
+        let __v_13: G = __loaded[11];
+        let __v_14: G = __loaded[12];
+        let __v_15: G = __loaded[13];
+        let __v_16: G = __loaded[14];
+        let __v_17: G = __loaded[15];
+        let __v_18: G = __loaded[16];
+        let __v_19: G = __loaded[17];
+        let __v_20: G = __loaded[18];
+        let __v_21: G = __loaded[19];
+        let __v_22: G = __loaded[20];
+        let __v_23: G = __loaded[21];
+        let __v_24: G = __loaded[22];
+        let __v_25: G = __loaded[23];
+        let __v_26: G = __loaded[24];
+        let __v_27: G = __loaded[25];
+        let __v_28: G = __loaded[26];
+        let __v_29: G = __loaded[27];
+        let __v_30: G = __loaded[28];
+        let __v_31: G = __loaded[29];
+        let __v_32: G = __loaded[30];
+        let __v_33: G = __loaded[31];
+        let __v_34: G = __loaded[32];
+        let __v_35: G = __loaded[33];
+        let __v_36: G = __loaded[34];
+        let __v_37: G = __loaded[35];
+        let __v_38: G = __loaded[36];
+        let __v_39: G = __loaded[37];
+        let __v_40: G = __loaded[38];
+        let __v_41: G = __loaded[39];
+        let __v_42: G = __loaded[40];
+        let __v_43: G = __loaded[41];
+        let __v_44: G = __loaded[42];
+        let __v_45: G = __loaded[43];
+        let __v_46: G = __loaded[44];
+        let __v_47: G = __loaded[45];
+        match __v_2.as_canonical_u64() {
           1u64 => {
-            let __v_49: G = G::from_u64(1);
-            let __v_50: G = (__v_1 + __v_49);
-            let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } };
-            let __v_51: G = __r_arr[0];
-            let __ret: [G; OUT_582] = [__v_51];
+            let __v_48: G = G::from_u64(1);
+            let __v_49: G = (__v_1 + __v_48);
+            let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_47, __v_49]; 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_50: G = __r_arr[0];
+            let __ret: [G; OUT_582] = [__v_50];
             record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } };
-            let __v_49: G = __r_arr[0];
-            let __ret: [G; OUT_582] = [__v_49];
+            let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_47, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } };
+            let __v_48: G = __r_arr[0];
+            let __ret: [G; OUT_582] = [__v_48];
             record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -49861,7 +49159,7 @@ fn aiur_fn_583(
     let __v_7: G = (__v_1 + __v_6);
     let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_7]; 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_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_9: G = __loaded[0];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
@@ -49871,7 +49169,7 @@ fn aiur_fn_583(
         let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_15: G = __loaded[0];
         let __v_16: G = __loaded[1];
         let __v_17: G = __loaded[2];
@@ -49923,7 +49221,7 @@ fn aiur_fn_584(
         let __v_14: G = (__v_13 + __v_4);
         let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_14]; 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_15: G = __r_arr[0];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_16: G = __loaded[0];
         let __v_17: G = __loaded[1];
         let __v_18: G = __loaded[2];
@@ -49933,7 +49231,7 @@ fn aiur_fn_584(
             let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_17]; 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_20: G = __r_arr[0];
             let __v_21: G = __r_arr[1];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_22: G = __loaded[0];
             let __v_23: G = __loaded[1];
             let __v_24: G = __loaded[2];
@@ -49945,30 +49243,24 @@ fn aiur_fn_584(
                 return Ok(__ret);
               },
               _ => {
-                let __v_26: G = G::from_u64(1);
-                let __v_27: G = G::from_u64(1);
-                let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_584] = [__v_28];
+                let __v_26: G = G::from_u64(0);
+                let __ret: [G; OUT_584] = [__v_26];
                 record.function_queries[584].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 __ret: [G; OUT_584] = [__v_22];
+            let __v_20: G = G::from_u64(0);
+            let __ret: [G; OUT_584] = [__v_20];
             record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_584] = [__v_14];
+        let __v_12: G = G::from_u64(0);
+        let __ret: [G; OUT_584] = [__v_12];
         record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -49997,7 +49289,7 @@ fn aiur_fn_585(
     let __v_8: G = (__v_1 + __v_7);
     let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_8]; 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_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_10: G = __loaded[0];
     let __v_11: G = __loaded[1];
     let __v_12: G = __loaded[2];
@@ -50007,7 +49299,7 @@ fn aiur_fn_585(
         let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_15, __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 __v_16: G = __r_arr[0];
         let __v_17: G = (__v_2 + __v_3);
         let __v_18: G = (__v_17 + __v_4);
@@ -50036,41 +49328,34 @@ fn aiur_fn_586(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_586] = [__v_7];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_586] = [__v_2];
         record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_3, __v_5, __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_6: G = __r_arr[0];
-        let __v_7: G = G::from_u64(0);
-        if (__v_6 != __v_7) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("nested occurrence's parameter references a motive, minor, or index binder".to_string()) });
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_2, __v_4, __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_5: G = __r_arr[0];
+        let __v_6: G = G::from_u64(0);
+        if (__v_5 != __v_6) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("nested occurrence's parameter references a motive, minor, or index binder".to_string()) });
         }
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3, __v_1, __v_9]; 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_586] = [__v_12];
+        let __v_7: G = G::from_u64(0);
+        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_1, __v_7]; 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_8: G = __r_arr[0];
+        let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __v_10: G = { let __values: [G; 2] = [__v_8, __v_9]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_586] = [__v_10];
         record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -50091,25 +49376,22 @@ fn aiur_fn_587(
     let __v_3: G = (__v_1 - __v_2);
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_587] = [__v_6];
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_587] = [__v_4];
         record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_4: G = G::from_u64(0);
-        let __v_5: G = G::from_u64(4);
-        let __v_6: G = (__v_0 + __v_2);
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_1, __v_10]; 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_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_587] = [__v_12];
+        let __v_4: G = G::from_u64(4);
+        let __v_5: G = (__v_0 + __v_2);
+        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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_2 + __v_8);
+        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = { let __values: [G; 2] = [__v_7, __v_10]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_587] = [__v_11];
         record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -50192,7 +49474,7 @@ fn aiur_fn_588(
           _ => {
             let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; 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_50: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_51: G = __loaded[0];
             let __v_52: G = __loaded[1];
             let __v_53: G = __loaded[2];
@@ -50212,22 +49494,15 @@ fn aiur_fn_588(
                 let __v_64: G = __r_arr[0];
                 let __v_65: G = G::from_u64(0);
                 let __v_66: G = G::from_u64(0);
-                let __v_67: G = G::from_u64(1);
-                let __v_68: G = G::from_u64(1);
-                let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_70: G = G::from_u64(1);
-                let __v_71: G = G::from_u64(1);
-                let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_588] = [__v_73];
+                let __v_67: G = G::from_u64(0);
+                let __v_68: G = { let __values: [G; 5] = [__v_0, __v_65, __v_66, __v_64, __v_67]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_588] = [__v_68];
                 record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_63: G = G::from_u64(1);
-                let __v_64: G = G::from_u64(1);
-                let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_588] = [__v_65];
+                let __v_63: G = G::from_u64(0);
+                let __ret: [G; OUT_588] = [__v_63];
                 record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -50254,125 +49529,116 @@ fn aiur_fn_589(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    let __v_8: G = __loaded[3];
-    let __v_9: G = __loaded[4];
-    let __v_10: G = __loaded[5];
-    let __v_11: G = __loaded[6];
-    let __v_12: G = __loaded[7];
-    let __v_13: G = __loaded[8];
-    let __v_14: G = __loaded[9];
-    let __v_15: G = __loaded[10];
-    let __v_16: G = __loaded[11];
-    let __v_17: G = __loaded[12];
-    let __v_18: G = __loaded[13];
-    let __v_19: G = __loaded[14];
-    let __v_20: G = __loaded[15];
-    let __v_21: G = __loaded[16];
-    let __v_22: G = __loaded[17];
-    let __v_23: G = __loaded[18];
-    let __v_24: G = __loaded[19];
-    let __v_25: G = __loaded[20];
-    let __v_26: G = __loaded[21];
-    let __v_27: G = __loaded[22];
-    let __v_28: G = __loaded[23];
-    let __v_29: G = __loaded[24];
-    let __v_30: G = __loaded[25];
-    let __v_31: G = __loaded[26];
-    let __v_32: G = __loaded[27];
-    let __v_33: G = __loaded[28];
-    let __v_34: G = __loaded[29];
-    let __v_35: G = __loaded[30];
-    let __v_36: G = __loaded[31];
-    let __v_37: G = __loaded[32];
-    let __v_38: G = __loaded[33];
-    let __v_39: G = __loaded[34];
-    let __v_40: G = __loaded[35];
-    let __v_41: G = __loaded[36];
-    let __v_42: G = __loaded[37];
-    let __v_43: G = __loaded[38];
-    let __v_44: G = __loaded[39];
-    let __v_45: G = __loaded[40];
-    let __v_46: G = __loaded[41];
-    let __v_47: G = __loaded[42];
-    let __v_48: G = __loaded[43];
-    let __v_49: G = __loaded[44];
-    let __v_50: G = __loaded[45];
-    let __v_51: G = __loaded[46];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
-        let __v_52: G = G::from_u64(1);
-        let __v_53: G = G::from_u64(1);
-        let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_589] = [__v_54];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_589] = [__v_5];
         record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_6.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        let __v_9: G = __loaded[4];
+        let __v_10: G = __loaded[5];
+        let __v_11: G = __loaded[6];
+        let __v_12: G = __loaded[7];
+        let __v_13: G = __loaded[8];
+        let __v_14: G = __loaded[9];
+        let __v_15: G = __loaded[10];
+        let __v_16: G = __loaded[11];
+        let __v_17: G = __loaded[12];
+        let __v_18: G = __loaded[13];
+        let __v_19: G = __loaded[14];
+        let __v_20: G = __loaded[15];
+        let __v_21: G = __loaded[16];
+        let __v_22: G = __loaded[17];
+        let __v_23: G = __loaded[18];
+        let __v_24: G = __loaded[19];
+        let __v_25: G = __loaded[20];
+        let __v_26: G = __loaded[21];
+        let __v_27: G = __loaded[22];
+        let __v_28: G = __loaded[23];
+        let __v_29: G = __loaded[24];
+        let __v_30: G = __loaded[25];
+        let __v_31: G = __loaded[26];
+        let __v_32: G = __loaded[27];
+        let __v_33: G = __loaded[28];
+        let __v_34: G = __loaded[29];
+        let __v_35: G = __loaded[30];
+        let __v_36: G = __loaded[31];
+        let __v_37: G = __loaded[32];
+        let __v_38: G = __loaded[33];
+        let __v_39: G = __loaded[34];
+        let __v_40: G = __loaded[35];
+        let __v_41: G = __loaded[36];
+        let __v_42: G = __loaded[37];
+        let __v_43: G = __loaded[38];
+        let __v_44: G = __loaded[39];
+        let __v_45: G = __loaded[40];
+        let __v_46: G = __loaded[41];
+        let __v_47: G = __loaded[42];
+        let __v_48: G = __loaded[43];
+        let __v_49: G = __loaded[44];
+        let __v_50: G = __loaded[45];
+        match __v_5.as_canonical_u64() {
           1u64 => {
             let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_2, __v_4]; 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_52: G = __r_arr[0];
+            let __v_51: G = __r_arr[0];
             let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_4]; 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_53: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-            let __v_54: G = __loaded[0];
-            let __v_55: G = __loaded[1];
-            let __v_56: G = __loaded[2];
-            let __v_57: G = __loaded[3];
-            let __v_58: G = __loaded[4];
-            let __v_59: G = __loaded[5];
-            let __v_60: G = __loaded[6];
-            let __v_61: G = __loaded[7];
-            let __v_62: G = __loaded[8];
-            let __v_63: G = __loaded[9];
-            let __v_64: G = __loaded[10];
-            let __v_65: G = __loaded[11];
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_54.as_canonical_u64() {
+            let __v_52: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_52.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_53: G = __loaded[0];
+            let __v_54: G = __loaded[1];
+            let __v_55: G = __loaded[2];
+            let __v_56: G = __loaded[3];
+            let __v_57: G = __loaded[4];
+            let __v_58: G = __loaded[5];
+            let __v_59: G = __loaded[6];
+            let __v_60: G = __loaded[7];
+            let __v_61: G = __loaded[8];
+            let __v_62: G = __loaded[9];
+            let __v_63: G = __loaded[10];
+            let __v_64: G = __loaded[11];
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_53.as_canonical_u64() {
   5u64 => {
-    break '__mc_0 [__v_55];
+    break '__mc_0 [__v_54];
   },
   _ => {
-    let __v_66: G = G::from_u64(0);
-    break '__mc_0 [__v_66];
+    let __v_65: G = G::from_u64(0);
+    break '__mc_0 [__v_65];
   },
 }
  };
-            let __v_66: G = __mc_out___mc_0[0];
-            let __v_67: G = G::from_u64(0);
-            let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_3, __v_66, __v_67]; 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_68: G = __r_arr[0];
+            let __v_65: G = __mc_out___mc_0[0];
+            let __v_66: G = G::from_u64(0);
+            let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_3, __v_65, __v_66]; 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_67: G = __r_arr[0];
+            let __v_68: G = G::from_u64(0);
             let __v_69: G = G::from_u64(0);
-            let __v_70: G = G::from_u64(0);
-            let __v_71: G = G::from_u64(1);
-            let __v_72: G = G::from_u64(1);
-            let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_74: G = G::from_u64(1);
-            let __v_75: G = (__v_4 + __v_74);
-            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_51, __v_2, __v_3, __v_75]; 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_76: G = __r_arr[0];
-            let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_589] = [__v_77];
+            let __v_70: G = G::from_u64(1);
+            let __v_71: G = (__v_4 + __v_70);
+            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_50, __v_2, __v_3, __v_71]; 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_72: G = __r_arr[0];
+            let __v_73: G = { let __values: [G; 5] = [__v_51, __v_68, __v_69, __v_67, __v_72]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_589] = [__v_73];
             record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_52: G = G::from_u64(1);
-            let __v_53: G = (__v_4 + __v_52);
-            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_51, __v_2, __v_3, __v_53]; 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_54: G = __r_arr[0];
-            let __ret: [G; OUT_589] = [__v_54];
+            let __v_51: G = G::from_u64(1);
+            let __v_52: G = (__v_4 + __v_51);
+            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_50, __v_2, __v_3, __v_52]; 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_53: G = __r_arr[0];
+            let __ret: [G; OUT_589] = [__v_53];
             record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
     }
   })
 }
@@ -50390,66 +49656,62 @@ fn aiur_fn_590(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_590] = [__v_9];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_590] = [__v_3];
         record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_5.as_canonical_u64() {
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        let __v_7: G = __loaded[4];
+        match __v_4.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            match __v_9.as_canonical_u64() {
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            match __v_8.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_6, __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 __v_10: G = __r_arr[0];
-                match __v_10.as_canonical_u64() {
+                let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_5, __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 __v_9: G = __r_arr[0];
+                match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __v_11: G = G::from_u64(1);
-                    let __ret: [G; OUT_590] = [__v_11];
+                    let __v_10: G = G::from_u64(1);
+                    let __ret: [G; OUT_590] = [__v_10];
                     record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } };
-                    let __v_11: G = __r_arr[0];
-                    let __ret: [G; OUT_590] = [__v_11];
+                    let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } };
+                    let __v_10: G = __r_arr[0];
+                    let __ret: [G; OUT_590] = [__v_10];
                     record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } };
-                let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_590] = [__v_10];
+                let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_7, __v_1, __v_2]; 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_9: G = __r_arr[0];
+                let __ret: [G; OUT_590] = [__v_9];
                 record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_8, __v_1, __v_2]; 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_9: G = __r_arr[0];
-            let __ret: [G; OUT_590] = [__v_9];
+            let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __ret: [G; OUT_590] = [__v_8];
             record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -50475,14 +49737,14 @@ fn aiur_fn_591(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_3: G = __loaded[0];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
         let __v_6: G = __loaded[3];
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_7: G = __loaded[0];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
@@ -50514,7 +49776,7 @@ fn aiur_fn_591(
             }
           },
           1u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_7: G = __loaded[0];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
@@ -50536,7 +49798,7 @@ fn aiur_fn_591(
             }
           },
           2u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_7: G = __loaded[0];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
@@ -50570,7 +49832,7 @@ fn aiur_fn_591(
             }
           },
           3u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_7: G = __loaded[0];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
@@ -50604,7 +49866,7 @@ fn aiur_fn_591(
             }
           },
           4u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_7: G = __loaded[0];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
@@ -50638,7 +49900,7 @@ fn aiur_fn_591(
             }
           },
           5u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_7: G = __loaded[0];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
@@ -50672,7 +49934,7 @@ fn aiur_fn_591(
             }
           },
           6u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_7: G = __loaded[0];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
@@ -50718,7 +49980,7 @@ fn aiur_fn_591(
             }
           },
           7u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_7: G = __loaded[0];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
@@ -50740,7 +50002,7 @@ fn aiur_fn_591(
             }
           },
           8u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_7: G = __loaded[0];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
@@ -50805,70 +50067,58 @@ fn aiur_fn_592(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_592] = [__v_8];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_2: G = G::from_u64(1);
+            let __ret: [G; OUT_592] = [__v_2];
             record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_592] = [__v_8];
+            let __v_2: G = G::from_u64(0);
+            let __ret: [G; OUT_592] = [__v_2];
             record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_592] = [__v_8];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_592] = [__v_4];
             record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            match __v_8.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_4: G = __loaded[0];
+            let __v_5: G = __loaded[1];
+            let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            match __v_6.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } };
-                let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_592] = [__v_9];
+                let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } };
+                let __v_7: G = __r_arr[0];
+                let __ret: [G; OUT_592] = [__v_7];
                 record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_592] = [__v_9];
+                let __v_7: G = G::from_u64(0);
+                let __ret: [G; OUT_592] = [__v_7];
                 record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -50885,70 +50135,58 @@ fn aiur_fn_593(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_593] = [__v_8];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_2: G = G::from_u64(1);
+            let __ret: [G; OUT_593] = [__v_2];
             record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_593] = [__v_8];
+            let __v_2: G = G::from_u64(0);
+            let __ret: [G; OUT_593] = [__v_2];
             record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_593] = [__v_8];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_593] = [__v_4];
             record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_3, __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 __v_8: G = __r_arr[0];
-            match __v_8.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_4: G = __loaded[0];
+            let __v_5: G = __loaded[1];
+            let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            match __v_6.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_4, __v_7]; 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_593] = [__v_9];
+                let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } };
+                let __v_7: G = __r_arr[0];
+                let __ret: [G; OUT_593] = [__v_7];
                 record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_593] = [__v_9];
+                let __v_7: G = G::from_u64(0);
+                let __ret: [G; OUT_593] = [__v_7];
                 record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -50985,10 +50223,8 @@ fn aiur_fn_594(
         return Ok(__ret);
       },
       _ => {
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = G::from_u64(1);
-        let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_594] = [__v_15];
+        let __v_13: G = G::from_u64(0);
+        let __ret: [G; OUT_594] = [__v_13];
         record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -51094,102 +50330,101 @@ fn aiur_fn_596(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    let __v_8: G = __loaded[3];
-    let __v_9: G = __loaded[4];
-    let __v_10: G = __loaded[5];
-    let __v_11: G = __loaded[6];
-    let __v_12: G = __loaded[7];
-    let __v_13: G = __loaded[8];
-    let __v_14: G = __loaded[9];
-    let __v_15: G = __loaded[10];
-    let __v_16: G = __loaded[11];
-    let __v_17: G = __loaded[12];
-    let __v_18: G = __loaded[13];
-    let __v_19: G = __loaded[14];
-    let __v_20: G = __loaded[15];
-    let __v_21: G = __loaded[16];
-    let __v_22: G = __loaded[17];
-    let __v_23: G = __loaded[18];
-    let __v_24: G = __loaded[19];
-    let __v_25: G = __loaded[20];
-    let __v_26: G = __loaded[21];
-    let __v_27: G = __loaded[22];
-    let __v_28: G = __loaded[23];
-    let __v_29: G = __loaded[24];
-    let __v_30: G = __loaded[25];
-    let __v_31: G = __loaded[26];
-    let __v_32: G = __loaded[27];
-    let __v_33: G = __loaded[28];
-    let __v_34: G = __loaded[29];
-    let __v_35: G = __loaded[30];
-    let __v_36: G = __loaded[31];
-    let __v_37: G = __loaded[32];
-    let __v_38: G = __loaded[33];
-    let __v_39: G = __loaded[34];
-    let __v_40: G = __loaded[35];
-    let __v_41: G = __loaded[36];
-    let __v_42: G = __loaded[37];
-    let __v_43: G = __loaded[38];
-    let __v_44: G = __loaded[39];
-    let __v_45: G = __loaded[40];
-    let __v_46: G = __loaded[41];
-    let __v_47: G = __loaded[42];
-    let __v_48: G = __loaded[43];
-    let __v_49: G = __loaded[44];
-    let __v_50: G = __loaded[45];
-    let __v_51: G = __loaded[46];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_596] = [__v_4];
         record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_6.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        let __v_9: G = __loaded[4];
+        let __v_10: G = __loaded[5];
+        let __v_11: G = __loaded[6];
+        let __v_12: G = __loaded[7];
+        let __v_13: G = __loaded[8];
+        let __v_14: G = __loaded[9];
+        let __v_15: G = __loaded[10];
+        let __v_16: G = __loaded[11];
+        let __v_17: G = __loaded[12];
+        let __v_18: G = __loaded[13];
+        let __v_19: G = __loaded[14];
+        let __v_20: G = __loaded[15];
+        let __v_21: G = __loaded[16];
+        let __v_22: G = __loaded[17];
+        let __v_23: G = __loaded[18];
+        let __v_24: G = __loaded[19];
+        let __v_25: G = __loaded[20];
+        let __v_26: G = __loaded[21];
+        let __v_27: G = __loaded[22];
+        let __v_28: G = __loaded[23];
+        let __v_29: G = __loaded[24];
+        let __v_30: G = __loaded[25];
+        let __v_31: G = __loaded[26];
+        let __v_32: G = __loaded[27];
+        let __v_33: G = __loaded[28];
+        let __v_34: G = __loaded[29];
+        let __v_35: G = __loaded[30];
+        let __v_36: G = __loaded[31];
+        let __v_37: G = __loaded[32];
+        let __v_38: G = __loaded[33];
+        let __v_39: G = __loaded[34];
+        let __v_40: G = __loaded[35];
+        let __v_41: G = __loaded[36];
+        let __v_42: G = __loaded[37];
+        let __v_43: G = __loaded[38];
+        let __v_44: G = __loaded[39];
+        let __v_45: G = __loaded[40];
+        let __v_46: G = __loaded[41];
+        let __v_47: G = __loaded[42];
+        let __v_48: G = __loaded[43];
+        let __v_49: G = __loaded[44];
+        let __v_50: G = __loaded[45];
+        match __v_5.as_canonical_u64() {
           2u64 => {
             let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_2, __v_3]; 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_51: G = __r_arr[0];
+            let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_51]; 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_52: G = __r_arr[0];
-            let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
-            let __v_53: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-            let __v_54: G = __loaded[0];
-            let __v_55: G = __loaded[1];
-            let __v_56: G = __loaded[2];
-            let __v_57: G = __loaded[3];
-            let __v_58: G = __loaded[4];
-            let __v_59: G = __loaded[5];
-            let __v_60: G = __loaded[6];
-            let __v_61: G = __loaded[7];
-            let __v_62: G = __loaded[8];
-            let __v_63: G = __loaded[9];
-            let __v_64: G = __loaded[10];
-            let __v_65: G = __loaded[11];
-            match __v_54.as_canonical_u64() {
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_53: G = __loaded[0];
+            let __v_54: G = __loaded[1];
+            let __v_55: G = __loaded[2];
+            let __v_56: G = __loaded[3];
+            let __v_57: G = __loaded[4];
+            let __v_58: G = __loaded[5];
+            let __v_59: G = __loaded[6];
+            let __v_60: G = __loaded[7];
+            let __v_61: G = __loaded[8];
+            let __v_62: G = __loaded[9];
+            let __v_63: G = __loaded[10];
+            let __v_64: G = __loaded[11];
+            match __v_53.as_canonical_u64() {
               7u64 => {
-                let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_56, __v_57, __v_59, __v_60, __v_58]; 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_583] = { let __args: [G; IN_583] = [__v_55, __v_56, __v_58, __v_59, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } };
+                let __v_65: G = __r_arr[0];
+                let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_65]; 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_66: G = __r_arr[0];
-                let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_66]; 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_67: G = __r_arr[0];
-                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_67.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-                let __v_68: G = __loaded[0];
-                let __v_69: G = __loaded[1];
-                let __v_70: G = __loaded[2];
-                let __v_71: G = __loaded[3];
-                let __v_72: G = __loaded[4];
-                let __v_73: G = __loaded[5];
-                let __v_74: G = __loaded[6];
-                let __v_75: G = __loaded[7];
-                let __v_76: G = __loaded[8];
-                let __v_77: G = __loaded[9];
-                let __v_78: G = __loaded[10];
-                let __v_79: G = __loaded[11];
-                match __v_68.as_canonical_u64() {
+                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                let __v_67: G = __loaded[0];
+                let __v_68: G = __loaded[1];
+                let __v_69: G = __loaded[2];
+                let __v_70: G = __loaded[3];
+                let __v_71: G = __loaded[4];
+                let __v_72: G = __loaded[5];
+                let __v_73: G = __loaded[6];
+                let __v_74: G = __loaded[7];
+                let __v_75: G = __loaded[8];
+                let __v_76: G = __loaded[9];
+                let __v_77: G = __loaded[10];
+                let __v_78: G = __loaded[11];
+                match __v_67.as_canonical_u64() {
                   5u64 => {
-                    let __ret: [G; OUT_596] = [__v_75];
+                    let __ret: [G; OUT_596] = [__v_74];
                     record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
@@ -51208,19 +50443,16 @@ fn aiur_fn_596(
             }
           },
           _ => {
-            let __v_52: G = G::from_u64(1);
-            let __v_53: G = (__v_3 + __v_52);
-            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_51, __v_2, __v_53, __v_4]; 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_54: G = __r_arr[0];
-            let __ret: [G; OUT_596] = [__v_54];
+            let __v_51: G = G::from_u64(1);
+            let __v_52: G = (__v_3 + __v_51);
+            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __v_50, __v_2, __v_52, __v_4]; 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_53: G = __r_arr[0];
+            let __ret: [G; OUT_596] = [__v_53];
             record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
     }
   })
 }
@@ -51365,7 +50597,7 @@ fn aiur_fn_597(
       _ => {
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_51]; 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_100: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_101: G = __loaded[0];
         let __v_102: G = __loaded[1];
         let __v_103: G = __loaded[2];
@@ -51385,20 +50617,13 @@ fn aiur_fn_597(
             let __v_114: G = __r_arr[0];
             let __v_115: G = G::from_u64(0);
             let __v_116: G = G::from_u64(0);
-            let __v_117: G = G::from_u64(1);
-            let __v_118: G = G::from_u64(1);
-            let __v_119: G = { let __values: [G; 3] = [__v_117, __v_118, __v_118]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_120: G = G::from_u64(1);
-            let __v_121: G = G::from_u64(1);
-            let __v_122: G = { let __values: [G; 6] = [__v_120, __v_121, __v_121, __v_121, __v_121, __v_121]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_123: G = { let __values: [G; 6] = [__v_115, __v_51, __v_116, __v_119, __v_114, __v_122]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            break '__mc_1 [__v_123];
+            let __v_117: G = G::from_u64(0);
+            let __v_118: G = { let __values: [G; 5] = [__v_51, __v_115, __v_116, __v_114, __v_117]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            break '__mc_1 [__v_118];
           },
           _ => {
-            let __v_113: G = G::from_u64(1);
-            let __v_114: G = G::from_u64(1);
-            let __v_115: G = { let __values: [G; 6] = [__v_113, __v_114, __v_114, __v_114, __v_114, __v_114]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            break '__mc_1 [__v_115];
+            let __v_113: G = G::from_u64(0);
+            break '__mc_1 [__v_113];
           },
         }
       },
@@ -51528,175 +50753,174 @@ fn aiur_fn_599(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_7: G = __loaded[0];
-    let __v_8: G = __loaded[1];
-    let __v_9: G = __loaded[2];
-    let __v_10: G = __loaded[3];
-    let __v_11: G = __loaded[4];
-    let __v_12: G = __loaded[5];
-    let __v_13: G = __loaded[6];
-    let __v_14: G = __loaded[7];
-    let __v_15: G = __loaded[8];
-    let __v_16: G = __loaded[9];
-    let __v_17: G = __loaded[10];
-    let __v_18: G = __loaded[11];
-    let __v_19: G = __loaded[12];
-    let __v_20: G = __loaded[13];
-    let __v_21: G = __loaded[14];
-    let __v_22: G = __loaded[15];
-    let __v_23: G = __loaded[16];
-    let __v_24: G = __loaded[17];
-    let __v_25: G = __loaded[18];
-    let __v_26: G = __loaded[19];
-    let __v_27: G = __loaded[20];
-    let __v_28: G = __loaded[21];
-    let __v_29: G = __loaded[22];
-    let __v_30: G = __loaded[23];
-    let __v_31: G = __loaded[24];
-    let __v_32: G = __loaded[25];
-    let __v_33: G = __loaded[26];
-    let __v_34: G = __loaded[27];
-    let __v_35: G = __loaded[28];
-    let __v_36: G = __loaded[29];
-    let __v_37: G = __loaded[30];
-    let __v_38: G = __loaded[31];
-    let __v_39: G = __loaded[32];
-    let __v_40: G = __loaded[33];
-    let __v_41: G = __loaded[34];
-    let __v_42: G = __loaded[35];
-    let __v_43: G = __loaded[36];
-    let __v_44: G = __loaded[37];
-    let __v_45: G = __loaded[38];
-    let __v_46: G = __loaded[39];
-    let __v_47: G = __loaded[40];
-    let __v_48: G = __loaded[41];
-    let __v_49: G = __loaded[42];
-    let __v_50: G = __loaded[43];
-    let __v_51: G = __loaded[44];
-    let __v_52: G = __loaded[45];
-    let __v_53: G = __loaded[46];
-    match __v_7.as_canonical_u64() {
-      1u64 => {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_599] = [__v_5];
         record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_8.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __v_12: G = __loaded[5];
+        let __v_13: G = __loaded[6];
+        let __v_14: G = __loaded[7];
+        let __v_15: G = __loaded[8];
+        let __v_16: G = __loaded[9];
+        let __v_17: G = __loaded[10];
+        let __v_18: G = __loaded[11];
+        let __v_19: G = __loaded[12];
+        let __v_20: G = __loaded[13];
+        let __v_21: G = __loaded[14];
+        let __v_22: G = __loaded[15];
+        let __v_23: G = __loaded[16];
+        let __v_24: G = __loaded[17];
+        let __v_25: G = __loaded[18];
+        let __v_26: G = __loaded[19];
+        let __v_27: G = __loaded[20];
+        let __v_28: G = __loaded[21];
+        let __v_29: G = __loaded[22];
+        let __v_30: G = __loaded[23];
+        let __v_31: G = __loaded[24];
+        let __v_32: G = __loaded[25];
+        let __v_33: G = __loaded[26];
+        let __v_34: G = __loaded[27];
+        let __v_35: G = __loaded[28];
+        let __v_36: G = __loaded[29];
+        let __v_37: G = __loaded[30];
+        let __v_38: G = __loaded[31];
+        let __v_39: G = __loaded[32];
+        let __v_40: G = __loaded[33];
+        let __v_41: G = __loaded[34];
+        let __v_42: G = __loaded[35];
+        let __v_43: G = __loaded[36];
+        let __v_44: G = __loaded[37];
+        let __v_45: G = __loaded[38];
+        let __v_46: G = __loaded[39];
+        let __v_47: G = __loaded[40];
+        let __v_48: G = __loaded[41];
+        let __v_49: G = __loaded[42];
+        let __v_50: G = __loaded[43];
+        let __v_51: G = __loaded[44];
+        let __v_52: G = __loaded[45];
+        match __v_7.as_canonical_u64() {
           2u64 => {
             let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_2, __v_6]; 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];
+            let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_53]; 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_54: G = __r_arr[0];
-            let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_54]; 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_55: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-            let __v_56: G = __loaded[0];
-            let __v_57: G = __loaded[1];
-            let __v_58: G = __loaded[2];
-            let __v_59: G = __loaded[3];
-            let __v_60: G = __loaded[4];
-            let __v_61: G = __loaded[5];
-            let __v_62: G = __loaded[6];
-            let __v_63: G = __loaded[7];
-            let __v_64: G = __loaded[8];
-            let __v_65: G = __loaded[9];
-            let __v_66: G = __loaded[10];
-            let __v_67: G = __loaded[11];
-            let __mc_out___mc_0: [G; 5] = '__mc_0: { match __v_56.as_canonical_u64() {
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_55: G = __loaded[0];
+            let __v_56: G = __loaded[1];
+            let __v_57: G = __loaded[2];
+            let __v_58: G = __loaded[3];
+            let __v_59: G = __loaded[4];
+            let __v_60: G = __loaded[5];
+            let __v_61: G = __loaded[6];
+            let __v_62: G = __loaded[7];
+            let __v_63: G = __loaded[8];
+            let __v_64: G = __loaded[9];
+            let __v_65: G = __loaded[10];
+            let __v_66: G = __loaded[11];
+            let __mc_out___mc_0: [G; 5] = '__mc_0: { match __v_55.as_canonical_u64() {
   7u64 => {
-    let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_58, __v_59, __v_61, __v_62, __v_60]; 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_583] = { let __args: [G; IN_583] = [__v_57, __v_58, __v_60, __v_61, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } };
+    let __v_67: G = __r_arr[0];
+    let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_67]; 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_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
-    let __v_69: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-    let __v_70: G = __loaded[0];
-    let __v_71: G = __loaded[1];
-    let __v_72: G = __loaded[2];
-    let __v_73: G = __loaded[3];
-    let __v_74: G = __loaded[4];
-    let __v_75: G = __loaded[5];
-    let __v_76: G = __loaded[6];
-    let __v_77: G = __loaded[7];
-    let __v_78: G = __loaded[8];
-    let __v_79: G = __loaded[9];
-    let __v_80: G = __loaded[10];
-    let __v_81: G = __loaded[11];
-    match __v_70.as_canonical_u64() {
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_68.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __v_69: G = __loaded[0];
+    let __v_70: G = __loaded[1];
+    let __v_71: G = __loaded[2];
+    let __v_72: G = __loaded[3];
+    let __v_73: G = __loaded[4];
+    let __v_74: G = __loaded[5];
+    let __v_75: G = __loaded[6];
+    let __v_76: G = __loaded[7];
+    let __v_77: G = __loaded[8];
+    let __v_78: G = __loaded[9];
+    let __v_79: G = __loaded[10];
+    let __v_80: G = __loaded[11];
+    match __v_69.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_77, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-        let __v_82: G = __r_arr[0];
-        match __v_82.as_canonical_u64() {
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_76, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_81: G = __r_arr[0];
+        match __v_81.as_canonical_u64() {
           1u64 => {
+            let __v_82: G = G::from_u64(0);
             let __v_83: G = G::from_u64(0);
-            let __v_84: G = G::from_u64(0);
-            break '__mc_0 [__v_83, __v_68, __v_84, __v_73, __v_71];
+            break '__mc_0 [__v_82, __v_67, __v_83, __v_72, __v_70];
           },
           _ => {
+            let __v_82: G = G::from_u64(1);
             let __v_83: G = G::from_u64(1);
-            let __v_84: G = G::from_u64(1);
-            break '__mc_0 [__v_83, __v_68, __v_84, __v_73, __v_71];
+            break '__mc_0 [__v_82, __v_67, __v_83, __v_72, __v_70];
           },
         }
       },
       _ => {
+        let __v_81: G = G::from_u64(0);
         let __v_82: G = G::from_u64(0);
         let __v_83: G = G::from_u64(0);
         let __v_84: G = G::from_u64(0);
-        let __v_85: G = G::from_u64(0);
-        break '__mc_0 [__v_82, __v_68, __v_83, __v_84, __v_85];
+        break '__mc_0 [__v_81, __v_67, __v_82, __v_83, __v_84];
       },
     }
   },
   _ => {
+    let __v_67: G = G::from_u64(0);
     let __v_68: G = G::from_u64(0);
     let __v_69: G = G::from_u64(0);
     let __v_70: G = G::from_u64(0);
-    let __v_71: G = G::from_u64(0);
-    break '__mc_0 [__v_68, __v_3, __v_69, __v_70, __v_71];
+    break '__mc_0 [__v_67, __v_3, __v_68, __v_69, __v_70];
   },
 }
  };
-            let __v_68: G = __mc_out___mc_0[0];
-            let __v_69: G = __mc_out___mc_0[1];
-            let __v_70: G = __mc_out___mc_0[2];
-            let __v_71: G = __mc_out___mc_0[3];
-            let __v_72: G = __mc_out___mc_0[4];
-            match __v_68.as_canonical_u64() {
+            let __v_67: G = __mc_out___mc_0[0];
+            let __v_68: G = __mc_out___mc_0[1];
+            let __v_69: G = __mc_out___mc_0[2];
+            let __v_70: G = __mc_out___mc_0[3];
+            let __v_71: G = __mc_out___mc_0[4];
+            match __v_67.as_canonical_u64() {
               0u64 => {
-                let __v_73: G = G::from_u64(1);
-                let __v_74: G = (__v_6 + __v_73);
-                let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; 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_75: G = __r_arr[0];
-                let __ret: [G; OUT_599] = [__v_75];
+                let __v_72: G = G::from_u64(1);
+                let __v_73: G = (__v_6 + __v_72);
+                let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_52, __v_2, __v_3, __v_4, __v_5, __v_73]; 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_74: G = __r_arr[0];
+                let __ret: [G; OUT_599] = [__v_74];
                 record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_594] = { let __args: [G; IN_594] = [__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_70]; 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_72: G = __r_arr[0];
+                let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __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_73: G = __r_arr[0];
-                let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_590] = { let __args: [G; IN_590] = [__v_5, __v_68, __v_72]; 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_74: G = __r_arr[0];
-                let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_5, __v_69, __v_73]; 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_75: G = __r_arr[0];
-                match __v_75.as_canonical_u64() {
+                match __v_74.as_canonical_u64() {
                   1u64 => {
-                    let __v_76: G = G::from_u64(1);
-                    let __v_77: G = (__v_6 + __v_76);
-                    let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; 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_78: G = __r_arr[0];
-                    let __ret: [G; OUT_599] = [__v_78];
+                    let __v_75: G = G::from_u64(1);
+                    let __v_76: G = (__v_6 + __v_75);
+                    let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_52, __v_2, __v_3, __v_4, __v_5, __v_76]; 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_77: G = __r_arr[0];
+                    let __ret: [G; OUT_599] = [__v_77];
                     record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __v_76: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_5, __v_69, __v_76, __v_73, __v_74]; 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_77: G = __r_arr[0];
-                    let __v_78: G = G::from_u64(1);
-                    let __v_79: G = (__v_6 + __v_78);
-                    let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; 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_80: G = __r_arr[0];
-                    let __ret: [G; OUT_599] = [__v_80];
+                    let __v_75: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_5, __v_68, __v_75, __v_72, __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_76: G = __r_arr[0];
+                    let __v_77: G = G::from_u64(1);
+                    let __v_78: G = (__v_6 + __v_77);
+                    let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_52, __v_2, __v_3, __v_4, __v_76, __v_78]; 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_79: G = __r_arr[0];
+                    let __ret: [G; OUT_599] = [__v_79];
                     record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
@@ -51705,19 +50929,16 @@ fn aiur_fn_599(
             }
           },
           _ => {
-            let __v_54: G = G::from_u64(1);
-            let __v_55: G = (__v_6 + __v_54);
-            let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; 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_56: G = __r_arr[0];
-            let __ret: [G; OUT_599] = [__v_56];
+            let __v_53: G = G::from_u64(1);
+            let __v_54: G = (__v_6 + __v_53);
+            let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_52, __v_2, __v_3, __v_4, __v_5, __v_54]; 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_55: G = __r_arr[0];
+            let __ret: [G; OUT_599] = [__v_55];
             record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-      },
     }
   })
 }
@@ -51735,46 +50956,42 @@ fn aiur_fn_600(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_600] = [__v_9, __v_10];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_600] = [__v_3, __v_4];
         record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        match __v_9.as_canonical_u64() {
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        let __v_7: G = __loaded[4];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        match __v_8.as_canonical_u64() {
           1u64 => {
-            let __v_10: G = G::from_u64(1);
-            let __ret: [G; OUT_600] = [__v_10, __v_2];
+            let __v_9: G = G::from_u64(1);
+            let __ret: [G; OUT_600] = [__v_9, __v_2];
             record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_10: G = G::from_u64(1);
-            let __v_11: G = (__v_2 + __v_10);
-            let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_8, __v_1, __v_11]; 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_12: G = __r_arr[0];
-            let __v_13: G = __r_arr[1];
-            let __ret: [G; OUT_600] = [__v_12, __v_13];
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = (__v_2 + __v_9);
+            let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __v_12: G = __r_arr[1];
+            let __ret: [G; OUT_600] = [__v_11, __v_12];
             record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -51794,74 +51011,70 @@ fn aiur_fn_601(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-    let __v_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    let __v_8: G = __loaded[3];
-    let __v_9: G = __loaded[4];
-    let __v_10: G = __loaded[5];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_601] = [__v_11, __v_12];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_601] = [__v_5, __v_6];
         record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = (__v_2 - __v_7);
-        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_12.as_canonical_u64() {
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        let __v_9: G = __loaded[4];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = (__v_2 - __v_6);
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() {
   0u64 => {
-    let __v_13: G = G::from_u64(1);
-    break '__mc_0 [__v_13];
+    let __v_12: G = G::from_u64(1);
+    break '__mc_0 [__v_12];
   },
   _ => {
-    let __v_13: G = G::from_u64(0);
-    break '__mc_0 [__v_13];
+    let __v_12: G = G::from_u64(0);
+    break '__mc_0 [__v_12];
   },
 }
  };
-        let __v_13: G = __mc_out___mc_0[0];
+        let __v_12: G = __mc_out___mc_0[0];
         let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_2.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __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_14: G = __r_arr[0];
-    break '__mc_1 [__v_14];
+    let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_7, __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_13: G = __r_arr[0];
+    break '__mc_1 [__v_13];
   },
   _ => {
-    let __v_14: G = G::from_u64(1);
-    break '__mc_1 [__v_14];
+    let __v_13: G = G::from_u64(1);
+    break '__mc_1 [__v_13];
   },
 }
  };
-        let __v_14: G = __mc_out___mc_1[0];
-        let __v_15: G = (__v_11 * __v_13);
-        let __v_16: G = (__v_15 * __v_14);
-        match __v_16.as_canonical_u64() {
+        let __v_13: G = __mc_out___mc_1[0];
+        let __v_14: G = (__v_10 * __v_12);
+        let __v_15: G = (__v_14 * __v_13);
+        match __v_15.as_canonical_u64() {
           1u64 => {
-            let __v_17: G = G::from_u64(1);
-            let __ret: [G; OUT_601] = [__v_17, __v_4];
+            let __v_16: G = G::from_u64(1);
+            let __ret: [G; OUT_601] = [__v_16, __v_4];
             record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_17: G = G::from_u64(1);
-            let __v_18: G = (__v_4 + __v_17);
-            let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_10, __v_1, __v_2, __v_3, __v_18]; 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_19: G = __r_arr[0];
-            let __v_20: G = __r_arr[1];
-            let __ret: [G; OUT_601] = [__v_19, __v_20];
+            let __v_16: G = G::from_u64(1);
+            let __v_17: G = (__v_4 + __v_16);
+            let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_9, __v_1, __v_2, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } };
+            let __v_18: G = __r_arr[0];
+            let __v_19: G = __r_arr[1];
+            let __ret: [G; OUT_601] = [__v_18, __v_19];
             record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
     }
   })
 }
@@ -51878,15 +51091,14 @@ fn aiur_fn_602(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
@@ -51913,48 +51125,41 @@ fn aiur_fn_602(
         let __v_31: G = G::from_u64(0);
         let __v_32: G = G::from_u64(0);
         let __v_33: G = G::from_u64(0);
-        let __v_34: G = G::from_u64(0);
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_35: G = G::from_u64(0);
         let __v_36: G = G::from_u64(0);
         let __v_37: G = G::from_u64(0);
-        let __v_38: G = G::from_u64(0);
-        let __v_39: G = G::from_u64(0);
-        let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_41: G = G::from_u64(0);
-        let __v_42: G = G::from_u64(1);
-        let __v_43: G = G::from_u64(1);
-        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_45: G = G::from_u64(1);
-        let __v_46: G = G::from_u64(1);
-        let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_602] = [__v_40, __v_41, __v_44, __v_47];
+        let __ret: [G; OUT_602] = [__v_34, __v_35, __v_36, __v_37];
         record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
+      _ => {
+        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_602] = [__v_3, __v_4, __v_5, __v_6];
+            let __ret: [G; OUT_602] = [__v_2, __v_3, __v_4, __v_5];
             record.function_queries[602].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_602] = { let __args: [G; IN_602] = [__v_7, __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 __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_602] = [__v_10, __v_11, __v_12, __v_13];
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = (__v_1 - __v_7);
+            let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_6, __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 __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __v_11: G = __r_arr[2];
+            let __v_12: G = __r_arr[3];
+            let __ret: [G; OUT_602] = [__v_9, __v_10, __v_11, __v_12];
             record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -51980,18 +51185,18 @@ fn aiur_fn_603(
         let __v_6: G = (__v_1 - __v_5);
         let __v_7: G = (__v_6 - __v_0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __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));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_3]; 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_734] = { let __args: [G; IN_734] = [__v_3]; 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_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_726] = { let __args: [G; IN_726] = [__v_3, __v_0]; 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_727] = { let __args: [G; IN_727] = [__v_3, __v_0]; 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_6: G = __r_arr[0];
             let __ret: [G; OUT_603] = [__v_6];
             record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -52003,7 +51208,7 @@ fn aiur_fn_603(
             let __v_8: G = (__v_1 - __v_7);
             let __v_9: G = (__v_8 - __v_0);
             let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_603] = [__v_11];
             record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -52037,7 +51242,7 @@ fn aiur_fn_604(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -52082,59 +51287,51 @@ fn aiur_fn_605(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_605] = [__v_4];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_605] = [__v_2];
         record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
         let __v_5: G = __loaded[3];
         match __v_2.as_canonical_u64() {
           5u64 => {
-            let __v_6: G = G::from_u64(0);
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = (__v_1 - __v_7);
-            let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_4, __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 __v_9: G = __r_arr[0];
-            let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_605] = [__v_10];
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_4, __v_7]; 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_8: G = __r_arr[0];
+            let __v_9: G = { let __values: [G; 2] = [__v_3, __v_8]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_605] = [__v_9];
             record.function_queries[605].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_389] = { let __args: [G; IN_389] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-            let __v_10: G = __loaded[0];
-            let __v_11: G = __loaded[1];
-            let __v_12: G = __loaded[2];
-            let __v_13: G = __loaded[3];
-            match __v_10.as_canonical_u64() {
+            let __v_6: G = G::from_u64(0);
+            let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __v_8: G = __loaded[0];
+            let __v_9: G = __loaded[1];
+            let __v_10: G = __loaded[2];
+            let __v_11: G = __loaded[3];
+            match __v_8.as_canonical_u64() {
               5u64 => {
-                let __v_14: G = G::from_u64(0);
-                let __v_15: G = G::from_u64(1);
-                let __v_16: G = (__v_1 - __v_15);
-                let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_12, __v_16]; 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_17: G = __r_arr[0];
-                let __v_18: G = { let __values: [G; 3] = [__v_14, __v_11, __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_605] = [__v_18];
+                let __v_12: G = G::from_u64(1);
+                let __v_13: G = (__v_1 - __v_12);
+                let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_10, __v_13]; 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_14: G = __r_arr[0];
+                let __v_15: G = { let __values: [G; 2] = [__v_9, __v_14]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_605] = [__v_15];
                 record.function_queries[605].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_605] = [__v_16];
+                let __v_12: G = G::from_u64(0);
+                let __ret: [G; OUT_605] = [__v_12];
                 record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -52174,10 +51371,10 @@ fn aiur_fn_606(
         let __v_8: G = (__v_7 - __v_3);
         let __v_9: G = (__v_8 + __v_2);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_12: G = G::from_u64(3);
         let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __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_606] = { let __args: [G; IN_606] = [__v_14, __v_1, __v_2, __v_16]; 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)? } };
@@ -52203,32 +51400,28 @@ fn aiur_fn_607(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_607] = [__v_0];
         record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = 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_607] = { let __args: [G; IN_607] = [__v_10, __v_5, __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_11: G = __r_arr[0];
-        let __ret: [G; OUT_607] = [__v_11];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = G::from_u64(0);
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_2, __v_5]; 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_6: G = __r_arr[0];
+        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_6, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_9, __v_4, __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_10: G = __r_arr[0];
+        let __ret: [G; OUT_607] = [__v_10];
         record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -52294,10 +51487,10 @@ fn aiur_fn_609(
         let __v_6: G = (__v_1 - __v_5);
         let __v_7: G = (__v_6 - __v_2);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_10: G = G::from_u64(3);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __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_609] = { let __args: [G; IN_609] = [__v_12, __v_1, __v_14]; 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)? } };
@@ -52322,29 +51515,25 @@ fn aiur_fn_610(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_610] = [__v_0];
         record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_5: G = G::from_u64(5);
-        let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_4]; 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_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_610] = [__v_8];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = G::from_u64(5);
+        let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = { let __values: [G; 4] = [__v_4, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_610] = [__v_7];
         record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -52363,15 +51552,13 @@ fn aiur_fn_611(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_611] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_611] = [__v_2, __v_0];
         record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
@@ -52383,41 +51570,35 @@ fn aiur_fn_611(
             let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_4, __v_7]; 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_611] = [__v_11, __v_9];
+            let __v_10: G = { let __values: [G; 2] = [__v_3, __v_8]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_611] = [__v_10, __v_9];
             record.function_queries[611].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_389] = { let __args: [G; IN_389] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-            let __v_10: G = __loaded[0];
-            let __v_11: G = __loaded[1];
-            let __v_12: G = __loaded[2];
-            let __v_13: G = __loaded[3];
-            match __v_10.as_canonical_u64() {
+            let __v_6: G = G::from_u64(0);
+            let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __v_8: G = __loaded[0];
+            let __v_9: G = __loaded[1];
+            let __v_10: G = __loaded[2];
+            let __v_11: G = __loaded[3];
+            match __v_8.as_canonical_u64() {
               5u64 => {
-                let __v_14: G = G::from_u64(1);
-                let __v_15: G = (__v_1 - __v_14);
-                let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_12, __v_15]; 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 = __r_arr[1];
-                let __v_18: G = G::from_u64(0);
-                let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_611] = [__v_19, __v_17];
+                let __v_12: G = G::from_u64(1);
+                let __v_13: G = (__v_1 - __v_12);
+                let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_10, __v_13]; 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_14: G = __r_arr[0];
+                let __v_15: G = __r_arr[1];
+                let __v_16: G = { let __values: [G; 2] = [__v_9, __v_14]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_611] = [__v_16, __v_15];
                 record.function_queries[611].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_611] = [__v_16, __v_0];
+                let __v_12: G = G::from_u64(0);
+                let __ret: [G; OUT_611] = [__v_12, __v_0];
                 record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -52442,34 +51623,27 @@ fn aiur_fn_612(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_612] = [__v_8];
-        record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = (__v_2 + __v_8);
-        let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_5, __v_1, __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 __v_10: G = __r_arr[0];
-        let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_612] = [__v_11];
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_612] = [__v_3];
         record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_2 + __v_6);
+        let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_4, __v_1, __v_7]; 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_8: G = __r_arr[0];
+        let __v_9: G = { let __values: [G; 2] = [__v_5, __v_8]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_612] = [__v_9];
+        record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -52535,10 +51709,10 @@ fn aiur_fn_614(
         let __v_4: G = G::from_u64(0);
         let __v_5: G = (__v_1 - __v_2);
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_8: G = G::from_u64(3);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __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_614] = { let __args: [G; IN_614] = [__v_10, __v_1, __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)? } };
@@ -52579,7 +51753,7 @@ fn aiur_fn_615(
     let __v_12: G = __r_arr[0];
     let __v_13: G = G::from_u64(2);
     let __v_14: G = G::from_u64(0);
-    let __v_15: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_15: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() {
   0u64 => {
     let __v_16: G = G::from_u64(0);
@@ -52600,10 +51774,10 @@ fn aiur_fn_615(
     let __v_18: G = __r_arr[0];
     let __v_19: G = G::from_u64(1);
     let __v_20: G = G::from_u64(0);
-    let __v_21: G = { let __values: [G; 4] = [__v_19, __v_5, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_21: G = { let __values: [G; 4] = [__v_19, __v_5, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_22: G = G::from_u64(5);
     let __v_23: G = G::from_u64(0);
-    let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_24, __v_12]; 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_25: G = __r_arr[0];
     let __ret: [G; OUT_615] = [__v_25];
@@ -52659,10 +51833,10 @@ fn aiur_fn_617(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = (__v_2 - __v_3);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_9: G = G::from_u64(3);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __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_617] = { let __args: [G; IN_617] = [__v_11, __v_1, __v_2, __v_13]; 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)? } };
@@ -52687,29 +51861,25 @@ fn aiur_fn_618(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_618] = [__v_0];
         record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_5: G = G::from_u64(4);
-        let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_0, __v_4]; 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_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_618] = [__v_8];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = G::from_u64(4);
+        let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_0, __v_3]; 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_5: G = __r_arr[0];
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = { let __values: [G; 4] = [__v_4, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_618] = [__v_7];
         record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -52741,7 +51911,7 @@ fn aiur_fn_619(
     let __v_13: G = __r_arr[3];
     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_15: G = __loaded[0];
     let __v_16: G = __loaded[1];
     let __v_17: G = __loaded[2];
@@ -52794,7 +51964,7 @@ fn aiur_fn_620(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_8]; 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_719] = { let __args: [G; IN_719] = [__v_8]; 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_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
     let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } };
@@ -52808,7 +51978,7 @@ fn aiur_fn_620(
     let __v_17: G = __r_arr[0];
     let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_8, __v_9, __v_4, __v_11, __v_4]; 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_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_18]; 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_734] = { let __args: [G; IN_734] = [__v_18]; 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_19: G = __r_arr[0];
     let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_16, __v_5]; 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_20: G = __r_arr[0];
@@ -52823,7 +51993,7 @@ fn aiur_fn_620(
     let __v_27: G = __r_arr[3];
     let __v_28: G = G::from_u64(2);
     let __v_29: G = G::from_u64(0);
-    let __v_30: G = { let __values: [G; 4] = [__v_28, __v_24, __v_27, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_30: G = { let __values: [G; 4] = [__v_28, __v_24, __v_27, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_31: G = (__v_4 + __v_11);
     let __v_32: G = (__v_31 + __v_19);
     let __v_33: G = (__v_32 + __v_5);
@@ -52857,7 +52027,7 @@ fn aiur_fn_620(
     let __v_46: G = (__v_44 - __v_45);
     let __v_47: G = G::from_u64(0);
     let __v_48: G = G::from_u64(0);
-    let __v_49: G = { let __values: [G; 4] = [__v_47, __v_46, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_49: G = { let __values: [G; 4] = [__v_47, __v_46, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_50: G = G::from_u64(0);
     let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_49, __v_5, __v_50]; 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_51: G = __r_arr[0];
@@ -52865,12 +52035,12 @@ fn aiur_fn_620(
     let __v_53: G = G::from_u64(0);
     let __v_54: G = G::from_u64(0);
     let __v_55: G = G::from_u64(0);
-    let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_57: G = G::from_u64(0);
-    let __v_58: G = { let __values: [G; 4] = [__v_52, __v_51, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_58: G = { let __values: [G; 4] = [__v_52, __v_51, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_59: G = G::from_u64(5);
     let __v_60: G = G::from_u64(0);
-    let __v_61: G = { let __values: [G; 4] = [__v_59, __v_40, __v_58, __v_60]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_61: G = { let __values: [G; 4] = [__v_59, __v_40, __v_58, __v_60]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_61, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } };
     let __v_62: G = __r_arr[0];
     let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_62, __v_18]; 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)? } };
@@ -52930,7 +52100,7 @@ fn aiur_fn_621(
     let __v_26: G = G::from_u64(0);
     let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_20, __v_21, __v_26]; 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_27: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_28: G = __loaded[0];
     let __v_29: G = __loaded[1];
     let __v_30: G = __loaded[2];
@@ -52953,9 +52123,9 @@ fn aiur_fn_621(
     let __v_29: G = G::from_u64(1);
     let __v_30: G = G::from_u64(0);
     let __v_31: G = G::from_u64(0);
-    let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_33: G = G::from_u64(0);
-    let __v_34: G = { let __values: [G; 4] = [__v_29, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_34: G = { let __values: [G; 4] = [__v_29, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_35: G = G::from_u64(0);
     let __v_36: G = G::from_u64(0);
     break '__mc_0 [__v_26, __v_27, __v_28, __v_34, __v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36];
@@ -52976,89 +52146,85 @@ fn aiur_fn_621(
             let __v_37: G = __mc_out___mc_0[11];
             let __v_38: G = __mc_out___mc_0[12];
             let __v_39: G = (__v_16 + __v_17);
-            let __v_40: G = G::from_u64(1);
-            let __v_41: G = G::from_u64(1);
-            let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_15, __v_39, __v_42]; 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_43: G = __r_arr[0];
-            let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_43, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_44: G = __r_arr[0];
-            let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_44.as_canonical_u64() {
+            let __v_40: G = G::from_u64(0);
+            let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_15, __v_39, __v_40]; 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_41: G = __r_arr[0];
+            let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_41, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_42: G = __r_arr[0];
+            let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_42.as_canonical_u64() {
   1u64 => {
-    let __v_45: G = G::from_u64(4);
-    let __v_46: G = G::from_u64(0);
-    let __v_47: G = G::from_u64(0);
-    let __v_48: G = { let __values: [G; 3] = [__v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    break '__mc_1 [__v_48];
+    let __v_43: G = G::from_u64(4);
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = G::from_u64(0);
+    let __v_46: G = { let __values: [G; 3] = [__v_43, __v_44, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    break '__mc_1 [__v_46];
   },
   _ => {
-    let __v_45: G = G::from_u64(0);
-    let __v_46: G = G::from_u64(0);
-    let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    break '__mc_1 [__v_47];
+    let __v_43: G = G::from_u64(0);
+    let __v_44: G = G::from_u64(0);
+    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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    break '__mc_1 [__v_45];
   },
 }
  };
-            let __v_45: G = __mc_out___mc_1[0];
-            let __v_46: G = G::from_u64(0);
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
+            let __v_43: G = __mc_out___mc_1[0];
+            let __v_44: G = G::from_u64(0);
+            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_44]; 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_45: G = __r_arr[0];
+            let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_10, __v_20, __v_42]; 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_46: G = __r_arr[0];
+            let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_46, __v_10, __v_12]; 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_47: G = __r_arr[0];
-            let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_10, __v_20, __v_44]; 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_631] = { let __args: [G; IN_631] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } };
             let __v_48: G = __r_arr[0];
-            let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_48, __v_10, __v_12]; 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_49: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } };
-            let __v_50: G = __r_arr[0];
             let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__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_51: G = __r_arr[0];
+            let __v_49: G = __r_arr[0];
             let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_20]; 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_52: G = __r_arr[0];
-            let __v_53: G = G::from_u64(1);
+            let __v_50: G = __r_arr[0];
+            let __v_51: G = G::from_u64(1);
             let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-            let __v_54: G = __r_arr[0];
-            let __v_55: G = (__v_53 - __v_54);
-            let __v_56: G = (__v_52 * __v_55);
-            let __v_57: G = (__v_51 * __v_56);
-            let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_57.as_canonical_u64() {
+            let __v_52: G = __r_arr[0];
+            let __v_53: G = (__v_51 - __v_52);
+            let __v_54: G = (__v_50 * __v_53);
+            let __v_55: G = (__v_49 * __v_54);
+            let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_55.as_canonical_u64() {
   1u64 => {
     let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_58: G = __r_arr[0];
-    break '__mc_2 [__v_58];
+    let __v_56: G = __r_arr[0];
+    break '__mc_2 [__v_56];
   },
   _ => {
-    let __v_58: G = G::from_u64(1);
-    let __v_59: G = G::from_u64(1);
-    let __v_60: G = { let __values: [G; 3] = [__v_58, __v_59, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    break '__mc_2 [__v_60];
+    let __v_56: G = G::from_u64(0);
+    break '__mc_2 [__v_56];
   },
 }
  };
-            let __v_58: G = __mc_out___mc_2[0];
-            let __v_59: G = G::from_u64(0);
-            let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_48, __v_25, __v_57, __v_58, __v_59]; 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_60: G = __r_arr[0];
-            let __v_61: G = __r_arr[1];
-            match __v_60.as_canonical_u64() {
+            let __v_56: G = __mc_out___mc_2[0];
+            let __v_57: G = G::from_u64(0);
+            let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_46, __v_25, __v_55, __v_56, __v_57]; 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_58: G = __r_arr[0];
+            let __v_59: G = __r_arr[1];
+            match __v_58.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_48, __v_61, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_622] = { let __args: [G; IN_622] = [__v_46, __v_59, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_45, __v_47, __v_48, __v_7, __v_2, __v_15, __v_14, __v_17, __v_43, __v_42]; 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 __ret: [G; OUT_621] = [];
                 record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_62: G = G::from_u64(0);
-                let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_48, __v_25, __v_62]; 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_63: G = __r_arr[0];
-                let __v_64: G = __r_arr[1];
-                match __v_63.as_canonical_u64() {
+                let __v_60: G = G::from_u64(0);
+                let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_46, __v_25, __v_60]; 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_61: G = __r_arr[0];
+                let __v_62: G = __r_arr[1];
+                match __v_61.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_48, __v_64, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_622] = { let __args: [G; IN_622] = [__v_46, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_45, __v_47, __v_48, __v_7, __v_2, __v_15, __v_14, __v_17, __v_43, __v_42]; 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 __ret: [G; OUT_621] = [];
                     record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_63.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
                   },
                 }
               },
@@ -53119,17 +52285,15 @@ fn aiur_fn_622(
     let __v_25: G = G::from_u64(0);
     let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_2, __v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_26: G = __r_arr[0];
-    let __v_27: G = G::from_u64(1);
-    let __v_28: G = G::from_u64(1);
-    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_12, __v_22, __v_29]; 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_30: G = __r_arr[0];
-    let __v_31: G = G::from_u64(1);
-    if (__v_30 != __v_31) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("recursor's declared type is not def-eq to the canonical reconstruction".to_string()) });
+    let __v_27: G = G::from_u64(0);
+    let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_12, __v_22, __v_27]; 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_28: G = __r_arr[0];
+    let __v_29: G = G::from_u64(1);
+    if (__v_28 != __v_29) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("recursor's declared type is not def-eq to the canonical reconstruction".to_string()) });
     }
-    let __v_32: G = G::from_u64(0);
-    let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_11, __v_26, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_30: G = G::from_u64(0);
+    let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_11, __v_26, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } };
     let __ret: [G; OUT_622] = [];
     record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -53158,59 +52322,55 @@ fn aiur_fn_623(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-        let __v_4: G = __loaded[0];
-        let __v_5: G = __loaded[1];
-        let __v_6: G = __loaded[2];
-        let __v_7: G = __loaded[3];
-        let __v_8: G = __loaded[4];
-        let __v_9: G = __loaded[5];
-        match __v_4.as_canonical_u64() {
-          1u64 => {
-            let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_623] = [__v_10];
+        match __v_0.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_623] = [__v_4];
             record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-            let __v_11: G = __loaded[0];
-            let __v_12: G = __loaded[1];
-            let __v_13: G = __loaded[2];
-            let __v_14: G = __loaded[3];
-            let __v_15: G = __loaded[4];
-            let __v_16: G = __loaded[5];
-            let __v_17: G = __loaded[6];
-            let __v_18: G = __loaded[7];
-            let __v_19: G = __loaded[8];
-            let __v_20: G = __loaded[9];
-            let __v_21: G = __loaded[10];
-            let __v_22: G = __loaded[11];
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() {
+          _ => {
+            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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+            let __v_4: G = __loaded[0];
+            let __v_5: G = __loaded[1];
+            let __v_6: G = __loaded[2];
+            let __v_7: G = __loaded[3];
+            let __v_8: G = __loaded[4];
+            let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_10: G = __loaded[0];
+            let __v_11: G = __loaded[1];
+            let __v_12: G = __loaded[2];
+            let __v_13: G = __loaded[3];
+            let __v_14: G = __loaded[4];
+            let __v_15: G = __loaded[5];
+            let __v_16: G = __loaded[6];
+            let __v_17: G = __loaded[7];
+            let __v_18: G = __loaded[8];
+            let __v_19: G = __loaded[9];
+            let __v_20: G = __loaded[10];
+            let __v_21: G = __loaded[11];
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() {
   5u64 => {
-    break '__mc_0 [__v_16];
+    break '__mc_0 [__v_15];
   },
   _ => {
-    let __v_23: G = G::from_u64(0);
-    break '__mc_0 [__v_23];
+    let __v_22: G = G::from_u64(0);
+    break '__mc_0 [__v_22];
   },
 }
  };
-            let __v_23: G = __mc_out___mc_0[0];
-            let __v_24: G = G::from_u64(1);
-            let __v_25: G = (__v_2 + __v_24);
-            let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_9, __v_1, __v_25]; 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_26: G = __r_arr[0];
-            let __v_27: G = (__v_23 + __v_26);
-            let __ret: [G; OUT_623] = [__v_27];
+            let __v_22: G = __mc_out___mc_0[0];
+            let __v_23: G = G::from_u64(1);
+            let __v_24: G = (__v_2 + __v_23);
+            let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_8, __v_1, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } };
+            let __v_25: G = __r_arr[0];
+            let __v_26: G = (__v_22 + __v_25);
+            let __ret: [G; OUT_623] = [__v_26];
             record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-          },
         }
       },
     }
@@ -53245,17 +52405,15 @@ fn aiur_fn_624(
     let __v_15: G = (__v_0 - __v_14);
     match __v_15.as_canonical_u64() {
       0u64 => {
-        let __v_16: G = G::from_u64(1);
-        let __v_17: G = G::from_u64(1);
-        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_624] = [__v_18];
+        let __v_16: G = G::from_u64(0);
+        let __ret: [G; OUT_624] = [__v_16];
         record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_2, __v_3, __v_14]; 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_16: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_17: G = __loaded[0];
         let __v_18: G = __loaded[1];
         let __v_19: G = __loaded[2];
@@ -53273,21 +52431,18 @@ fn aiur_fn_624(
             let __v_29: G = (__v_1 + __v_14);
             let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
             let __v_30: G = __r_arr[0];
-            let __v_31: G = G::from_u64(0);
-            let __v_32: G = G::from_u64(1);
-            let __v_33: G = (__v_14 + __v_32);
-            let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_34: G = __r_arr[0];
-            let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_624] = [__v_35];
+            let __v_31: G = G::from_u64(1);
+            let __v_32: G = (__v_14 + __v_31);
+            let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_0, __v_1, __v_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[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_33: G = __r_arr[0];
+            let __v_34: G = { let __values: [G; 2] = [__v_30, __v_33]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_624] = [__v_34];
             record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_29: G = G::from_u64(1);
-            let __v_30: G = G::from_u64(1);
-            let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_624] = [__v_31];
+            let __v_29: G = G::from_u64(0);
+            let __ret: [G; OUT_624] = [__v_29];
             record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -53316,107 +52471,95 @@ fn aiur_fn_625(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-    let __v_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    let __v_12: G = __loaded[3];
-    let __v_13: G = __loaded[4];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_625] = [];
         record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_10.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_9: G = __loaded[0];
+        let __v_10: G = __loaded[1];
+        let __v_11: G = __loaded[2];
+        let __v_12: G = __loaded[3];
+        match __v_9.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } else { aiur_fn_264(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-            let __v_15: G = __loaded[0];
-            let __v_16: G = __loaded[1];
-            let __v_17: G = __loaded[2];
-            let __v_18: G = __loaded[3];
-            let __v_19: G = __loaded[4];
-            let __v_20: G = __loaded[5];
-            let __v_21: G = __loaded[6];
-            let __v_22: G = __loaded[7];
-            let __v_23: G = __loaded[8];
-            let __v_24: G = __loaded[9];
-            let __v_25: G = __loaded[10];
-            let __v_26: G = __loaded[11];
-            let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_15.as_canonical_u64() {
+            let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_5, __v_6, __v_9]; 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_13: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_14: G = __loaded[0];
+            let __v_15: G = __loaded[1];
+            let __v_16: G = __loaded[2];
+            let __v_17: G = __loaded[3];
+            let __v_18: G = __loaded[4];
+            let __v_19: G = __loaded[5];
+            let __v_20: G = __loaded[6];
+            let __v_21: G = __loaded[7];
+            let __v_22: G = __loaded[8];
+            let __v_23: G = __loaded[9];
+            let __v_24: G = __loaded[10];
+            let __v_25: G = __loaded[11];
+            let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_14.as_canonical_u64() {
   6u64 => {
-    if (__v_11 != __v_22) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("recursor rule field count differs from the ctor's".to_string()) });
+    if (__v_10 != __v_21) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("recursor rule field count differs from the ctor's".to_string()) });
     }
     break '__mc_0 [];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+    return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
   },
 }
  };
-            if (__v_10 != __v_8) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("recursor rule is out of ctor order".to_string()) });
+            if (__v_9 != __v_8) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("recursor rule is out of ctor order".to_string()) });
             }
-            let __v_27: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-            let __v_28: G = G::from_u64(1);
-            if (__v_27 != __v_28) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("recursor rule names a ctor index out of range".to_string()) });
+            let __v_26: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+            let __v_27: G = G::from_u64(1);
+            if (__v_26 != __v_27) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("recursor rule names a ctor index out of range".to_string()) });
             }
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_29: G = __loaded[0];
-            let __v_30: G = __loaded[1];
-            let __v_31: G = __loaded[2];
-            match __v_29.as_canonical_u64() {
-              1u64 => {
+            match __v_1.as_canonical_u64() {
+              0u64 => {
                 let __ret: [G; OUT_625] = [];
                 record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
-              0u64 => {
-                let __v_32: G = (__v_2 + __v_3);
-                let __v_33: G = (__v_32 + __v_4);
-                let __v_34: G = (__v_33 + __v_11);
-                let __v_35: G = G::from_u64(0);
-                let __v_36: G = G::from_u64(1);
-                let __v_37: G = G::from_u64(1);
-                let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_12, __v_34, __v_35, __v_38]; 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_39: G = __r_arr[0];
-                let __v_40: G = __r_arr[1];
-                let __v_41: G = __r_arr[2];
-                if (__v_40 != __v_34) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("recursor rule rhs has too few binders to peel".to_string()) });
+              _ => {
+                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                let __v_28: G = __loaded[0];
+                let __v_29: G = __loaded[1];
+                let __v_30: G = (__v_2 + __v_3);
+                let __v_31: G = (__v_30 + __v_4);
+                let __v_32: G = (__v_31 + __v_10);
+                let __v_33: G = G::from_u64(0);
+                let __v_34: G = G::from_u64(0);
+                let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_11, __v_32, __v_33, __v_34]; 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_35: G = __r_arr[0];
+                let __v_36: G = __r_arr[1];
+                let __v_37: G = __r_arr[2];
+                if (__v_36 != __v_32) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("recursor rule rhs has too few binders to peel".to_string()) });
                 }
-                let __v_42: G = G::from_u64(1);
-                let __v_43: G = G::from_u64(1);
-                let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_39, __v_30, __v_44]; 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_45: G = __r_arr[0];
-                let __v_46: G = G::from_u64(1);
-                if (__v_45 != __v_46) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("recursor rule rhs differs from canonical reconstruction".to_string()) });
+                let __v_38: G = G::from_u64(0);
+                let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_35, __v_28, __v_38]; 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_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(), msg: Some("recursor rule rhs differs from canonical reconstruction".to_string()) });
                 }
-                let __v_47: G = G::from_u64(1);
-                let __v_48: G = (__v_8 + __v_47);
-                let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_41: G = G::from_u64(1);
+                let __v_42: G = (__v_8 + __v_41);
+                let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_12, __v_29, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } };
                 let __ret: [G; OUT_625] = [];
                 record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64()));
-              },
             }
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-      },
     }
   })
 }
@@ -53443,20 +52586,20 @@ fn aiur_fn_626(
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_12: G = __loaded[0];
-    let __v_13: G = __loaded[1];
-    let __v_14: G = __loaded[2];
-    match __v_12.as_canonical_u64() {
-      1u64 => {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_626] = [__v_0];
         record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_2, __v_11, __v_15]; 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_16: G = __r_arr[0];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = G::from_u64(0);
+        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_2, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = __r_arr[0];
+        let __v_16: G = G::from_u64(0);
         let __v_17: G = G::from_u64(0);
         let __v_18: G = G::from_u64(0);
         let __v_19: G = G::from_u64(0);
@@ -53488,93 +52631,87 @@ fn aiur_fn_626(
         let __v_45: G = G::from_u64(0);
         let __v_46: G = G::from_u64(0);
         let __v_47: G = G::from_u64(0);
-        let __v_48: G = G::from_u64(0);
-        let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4, __v_16, __v_49]; 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_50: G = __r_arr[0];
-        let __v_51: G = G::from_u64(0);
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } };
-        let __v_52: G = __r_arr[0];
-        let __v_53: G = (__v_6 + __v_7);
-        let __v_54: G = (__v_53 + __v_8);
-        let __v_55: G = (__v_54 + __v_9);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3, __v_13]; 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_56: G = __r_arr[0];
-        let __v_57: G = (__v_9 - __v_13);
-        let __v_58: G = G::from_u64(0);
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_56, __v_57, __v_58]; 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_59: G = __r_arr[0];
-        let __v_60: G = (__v_7 + __v_8);
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_59, __v_60, __v_9]; 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_48: G = { let __values: [G; 32] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4, __v_15, __v_48]; 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_49: G = __r_arr[0];
+        let __v_50: G = G::from_u64(0);
+        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_5, __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 __v_51: G = __r_arr[0];
+        let __v_52: G = (__v_6 + __v_7);
+        let __v_53: G = (__v_52 + __v_8);
+        let __v_54: G = (__v_53 + __v_9);
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_3, __v_12]; 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_55: G = __r_arr[0];
+        let __v_56: G = (__v_9 - __v_12);
+        let __v_57: G = G::from_u64(0);
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_55, __v_56, __v_57]; 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_58: G = __r_arr[0];
+        let __v_59: G = (__v_7 + __v_8);
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_58, __v_59, __v_9]; 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_60: G = __r_arr[0];
+        let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_60]; 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_61: G = __r_arr[0];
-        let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_61]; 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_62: G = __r_arr[0];
-        let __v_63: G = __r_arr[1];
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_62]; 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_64: G = __r_arr[0];
-        let __v_65: G = (__v_55 + __v_64);
-        let __v_66: G = G::from_u64(2);
-        let __v_67: G = G::from_u64(0);
-        let __v_68: G = { let __values: [G; 4] = [__v_66, __v_50, __v_10, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_69: G = G::from_u64(1);
-        let __v_70: G = (__v_65 - __v_69);
-        let __v_71: G = G::from_u64(0);
-        let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } };
-        let __v_72: G = __r_arr[0];
-        let __v_73: G = G::from_u64(1);
-        let __v_74: G = (__v_65 - __v_73);
-        let __v_75: G = (__v_74 - __v_6);
-        let __v_76: G = G::from_u64(0);
-        let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_72, __v_7, __v_75, __v_76]; 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_77: G = __r_arr[0];
-        let __v_78: G = G::from_u64(1);
-        let __v_79: G = (__v_65 - __v_78);
-        let __v_80: G = (__v_79 - __v_6);
-        let __v_81: G = (__v_80 - __v_7);
-        let __v_82: G = G::from_u64(0);
-        let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_77, __v_8, __v_81, __v_82]; 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_83: G = __r_arr[0];
-        let __v_84: G = G::from_u64(1);
-        let __v_85: G = G::from_u64(1);
-        let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_63, __v_86]; 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_62: G = __r_arr[1];
+        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_61]; 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_63: G = __r_arr[0];
+        let __v_64: G = (__v_54 + __v_63);
+        let __v_65: G = G::from_u64(2);
+        let __v_66: G = G::from_u64(0);
+        let __v_67: G = { let __values: [G; 4] = [__v_65, __v_49, __v_10, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_68: G = G::from_u64(1);
+        let __v_69: G = (__v_64 - __v_68);
+        let __v_70: G = G::from_u64(0);
+        let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_67, __v_6, __v_69, __v_70]; 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_71: G = __r_arr[0];
+        let __v_72: G = G::from_u64(1);
+        let __v_73: G = (__v_64 - __v_72);
+        let __v_74: G = (__v_73 - __v_6);
+        let __v_75: G = G::from_u64(0);
+        let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_71, __v_7, __v_74, __v_75]; 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_76: G = __r_arr[0];
+        let __v_77: G = G::from_u64(1);
+        let __v_78: G = (__v_64 - __v_77);
+        let __v_79: G = (__v_78 - __v_6);
+        let __v_80: G = (__v_79 - __v_7);
+        let __v_81: G = G::from_u64(0);
+        let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_76, __v_8, __v_80, __v_81]; 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_82: G = __r_arr[0];
+        let __v_83: G = G::from_u64(0);
+        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_62, __v_83]; 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_84: G = __r_arr[0];
+        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_84]; 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_85: G = __r_arr[0];
+        let __v_86: G = __r_arr[1];
+        let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_86, __v_51]; 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_87: G = __r_arr[0];
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_87]; 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_229] = { let __args: [G; IN_229] = [__v_82, __v_87]; 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_88: G = __r_arr[0];
-        let __v_89: G = __r_arr[1];
-        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_89, __v_52]; 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_90: G = __r_arr[0];
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_83, __v_90]; 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_91: G = __r_arr[0];
-        let __v_92: G = G::from_u64(1);
-        let __v_93: G = (__v_9 - __v_92);
-        let __v_94: G = (__v_93 - __v_13);
-        let __v_95: G = (__v_94 + __v_64);
+        let __v_89: G = G::from_u64(1);
+        let __v_90: G = (__v_9 - __v_89);
+        let __v_91: G = (__v_90 - __v_12);
+        let __v_92: G = (__v_91 + __v_63);
+        let __v_93: G = G::from_u64(0);
+        let __v_94: G = G::from_u64(0);
+        let __v_95: G = { let __values: [G; 4] = [__v_93, __v_92, __v_94, __v_94]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_96: G = G::from_u64(0);
-        let __v_97: G = G::from_u64(0);
-        let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_95, __v_63, __v_96]; 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_97: G = __r_arr[0];
+        let __v_98: G = G::from_u64(3);
         let __v_99: G = G::from_u64(0);
-        let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_98, __v_64, __v_99]; 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_100: G = __r_arr[0];
-        let __v_101: G = G::from_u64(3);
-        let __v_102: G = G::from_u64(0);
-        let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_103, __v_62]; 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_104: G = __r_arr[0];
-        let __v_105: G = G::from_u64(3);
-        let __v_106: G = G::from_u64(0);
-        let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_108: G = G::from_u64(1);
-        let __v_109: G = (__v_11 + __v_108);
-        let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_110: G = __r_arr[0];
-        let __ret: [G; OUT_626] = [__v_110];
+        let __v_100: G = { let __values: [G; 4] = [__v_98, __v_88, __v_97, __v_99]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_100, __v_61]; 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_101: G = __r_arr[0];
+        let __v_102: G = G::from_u64(3);
+        let __v_103: G = G::from_u64(0);
+        let __v_104: G = { let __values: [G; 4] = [__v_102, __v_0, __v_101, __v_103]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_105: G = G::from_u64(1);
+        let __v_106: G = (__v_11 + __v_105);
+        let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_104, __v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_106]; 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_107: G = __r_arr[0];
+        let __ret: [G; OUT_626] = [__v_107];
         record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-      },
     }
   })
 }
@@ -53616,37 +52753,31 @@ fn aiur_fn_627(
     let __v_21: G = G::from_u64(0);
     let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; 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_22: G = __r_arr[0];
-    let __v_23: G = G::from_u64(1);
-    let __v_24: G = G::from_u64(1);
-    let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_26: G = G::from_u64(1);
-    let __v_27: G = G::from_u64(1);
-    let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_29: G = G::from_u64(1);
-    let __v_30: G = G::from_u64(1);
-    let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_32: G = G::from_u64(0);
-    let __v_33: G = G::from_u64(0);
-    let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
-    let __v_34: G = __r_arr[0];
-    let __v_35: G = __r_arr[1];
-    let __v_36: G = __r_arr[2];
-    let __v_37: G = __r_arr[3];
-    let __v_38: G = G::from_u64(1);
-    let __v_39: G = (__v_19 - __v_38);
-    let __v_40: G = (__v_2 + __v_3);
-    let __v_41: G = (__v_40 + __v_1);
-    let __v_42: G = (__v_39 - __v_41);
-    let __v_43: G = G::from_u64(0);
-    let __v_44: G = G::from_u64(0);
-    let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_46: G = G::from_u64(0);
-    let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } };
-    let __v_47: G = __r_arr[0];
-    let __v_48: G = G::from_u64(0);
-    let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } };
-    let __v_49: G = __r_arr[0];
-    let __ret: [G; OUT_627] = [__v_49];
+    let __v_23: G = G::from_u64(0);
+    let __v_24: G = G::from_u64(0);
+    let __v_25: G = G::from_u64(0);
+    let __v_26: G = G::from_u64(0);
+    let __v_27: G = G::from_u64(0);
+    let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_22, __v_8, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
+    let __v_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 = G::from_u64(1);
+    let __v_33: G = (__v_19 - __v_32);
+    let __v_34: G = (__v_2 + __v_3);
+    let __v_35: G = (__v_34 + __v_1);
+    let __v_36: G = (__v_33 - __v_35);
+    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_37, __v_36, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_40: G = G::from_u64(0);
+    let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_39, __v_16, __v_16, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } };
+    let __v_41: G = __r_arr[0];
+    let __v_42: G = G::from_u64(0);
+    let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_41, __v_29, __v_30, __v_28, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_42]; 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_43: G = __r_arr[0];
+    let __ret: [G; OUT_627] = [__v_43];
     record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -53665,36 +52796,29 @@ fn aiur_fn_628(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __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_628] = [__v_11];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_628] = [__v_3];
         record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_1, __v_4, __v_6, __v_5, __v_2]; 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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        let __v_7: G = __loaded[4];
+        let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_1, __v_3, __v_5, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__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 __v_9: G = __r_arr[0];
-        let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_8, __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 __v_11: G = __r_arr[0];
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_628] = [__v_12];
+        let __v_10: G = { let __values: [G; 2] = [__v_8, __v_9]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_628] = [__v_10];
         record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -53803,172 +52927,168 @@ fn aiur_fn_630(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_8: G = __loaded[0];
-    let __v_9: G = __loaded[1];
-    let __v_10: G = __loaded[2];
-    let __v_11: G = __loaded[3];
-    let __v_12: G = __loaded[4];
-    let __v_13: G = __loaded[5];
-    let __v_14: G = __loaded[6];
-    let __v_15: G = __loaded[7];
-    let __v_16: G = __loaded[8];
-    let __v_17: G = __loaded[9];
-    let __v_18: G = __loaded[10];
-    let __v_19: G = __loaded[11];
-    let __v_20: G = __loaded[12];
-    let __v_21: G = __loaded[13];
-    let __v_22: G = __loaded[14];
-    let __v_23: G = __loaded[15];
-    let __v_24: G = __loaded[16];
-    let __v_25: G = __loaded[17];
-    let __v_26: G = __loaded[18];
-    let __v_27: G = __loaded[19];
-    let __v_28: G = __loaded[20];
-    let __v_29: G = __loaded[21];
-    let __v_30: G = __loaded[22];
-    let __v_31: G = __loaded[23];
-    let __v_32: G = __loaded[24];
-    let __v_33: G = __loaded[25];
-    let __v_34: G = __loaded[26];
-    let __v_35: G = __loaded[27];
-    let __v_36: G = __loaded[28];
-    let __v_37: G = __loaded[29];
-    let __v_38: G = __loaded[30];
-    let __v_39: G = __loaded[31];
-    let __v_40: G = __loaded[32];
-    let __v_41: G = __loaded[33];
-    let __v_42: G = __loaded[34];
-    let __v_43: G = __loaded[35];
-    let __v_44: G = __loaded[36];
-    let __v_45: G = __loaded[37];
-    let __v_46: G = __loaded[38];
-    let __v_47: G = __loaded[39];
-    let __v_48: G = __loaded[40];
-    let __v_49: G = __loaded[41];
-    let __v_50: G = __loaded[42];
-    let __v_51: G = __loaded[43];
-    let __v_52: G = __loaded[44];
-    let __v_53: G = __loaded[45];
-    let __v_54: G = __loaded[46];
-    match __v_8.as_canonical_u64() {
-      1u64 => {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_630] = [__v_6];
         record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_9.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_8: G = __loaded[0];
+        let __v_9: G = __loaded[1];
+        let __v_10: G = __loaded[2];
+        let __v_11: G = __loaded[3];
+        let __v_12: G = __loaded[4];
+        let __v_13: G = __loaded[5];
+        let __v_14: G = __loaded[6];
+        let __v_15: G = __loaded[7];
+        let __v_16: G = __loaded[8];
+        let __v_17: G = __loaded[9];
+        let __v_18: G = __loaded[10];
+        let __v_19: G = __loaded[11];
+        let __v_20: G = __loaded[12];
+        let __v_21: G = __loaded[13];
+        let __v_22: G = __loaded[14];
+        let __v_23: G = __loaded[15];
+        let __v_24: G = __loaded[16];
+        let __v_25: G = __loaded[17];
+        let __v_26: G = __loaded[18];
+        let __v_27: G = __loaded[19];
+        let __v_28: G = __loaded[20];
+        let __v_29: G = __loaded[21];
+        let __v_30: G = __loaded[22];
+        let __v_31: G = __loaded[23];
+        let __v_32: G = __loaded[24];
+        let __v_33: G = __loaded[25];
+        let __v_34: G = __loaded[26];
+        let __v_35: G = __loaded[27];
+        let __v_36: G = __loaded[28];
+        let __v_37: G = __loaded[29];
+        let __v_38: G = __loaded[30];
+        let __v_39: G = __loaded[31];
+        let __v_40: G = __loaded[32];
+        let __v_41: G = __loaded[33];
+        let __v_42: G = __loaded[34];
+        let __v_43: G = __loaded[35];
+        let __v_44: G = __loaded[36];
+        let __v_45: G = __loaded[37];
+        let __v_46: G = __loaded[38];
+        let __v_47: G = __loaded[39];
+        let __v_48: G = __loaded[40];
+        let __v_49: G = __loaded[41];
+        let __v_50: G = __loaded[42];
+        let __v_51: G = __loaded[43];
+        let __v_52: G = __loaded[44];
+        let __v_53: G = __loaded[45];
+        match __v_8.as_canonical_u64() {
           2u64 => {
             let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_2, __v_7]; 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_54: G = __r_arr[0];
+            let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_54]; 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_55: G = __r_arr[0];
-            let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_55]; 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_56: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-            let __v_57: G = __loaded[0];
-            let __v_58: G = __loaded[1];
-            let __v_59: G = __loaded[2];
-            let __v_60: G = __loaded[3];
-            let __v_61: G = __loaded[4];
-            let __v_62: G = __loaded[5];
-            let __v_63: G = __loaded[6];
-            let __v_64: G = __loaded[7];
-            let __v_65: G = __loaded[8];
-            let __v_66: G = __loaded[9];
-            let __v_67: G = __loaded[10];
-            let __v_68: G = __loaded[11];
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_57.as_canonical_u64() {
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_56: G = __loaded[0];
+            let __v_57: G = __loaded[1];
+            let __v_58: G = __loaded[2];
+            let __v_59: G = __loaded[3];
+            let __v_60: G = __loaded[4];
+            let __v_61: G = __loaded[5];
+            let __v_62: G = __loaded[6];
+            let __v_63: G = __loaded[7];
+            let __v_64: G = __loaded[8];
+            let __v_65: G = __loaded[9];
+            let __v_66: G = __loaded[10];
+            let __v_67: G = __loaded[11];
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_56.as_canonical_u64() {
   7u64 => {
-    let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_59, __v_60, __v_62, __v_63, __v_61]; 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_583] = { let __args: [G; IN_583] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } };
+    let __v_68: G = __r_arr[0];
+    let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
     let __v_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_69]; 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_70: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-    let __v_71: G = __loaded[0];
-    let __v_72: G = __loaded[1];
-    let __v_73: G = __loaded[2];
-    let __v_74: G = __loaded[3];
-    let __v_75: G = __loaded[4];
-    let __v_76: G = __loaded[5];
-    let __v_77: G = __loaded[6];
-    let __v_78: G = __loaded[7];
-    let __v_79: G = __loaded[8];
-    let __v_80: G = __loaded[9];
-    let __v_81: G = __loaded[10];
-    let __v_82: G = __loaded[11];
-    let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_71.as_canonical_u64() {
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __v_70: G = __loaded[0];
+    let __v_71: G = __loaded[1];
+    let __v_72: G = __loaded[2];
+    let __v_73: G = __loaded[3];
+    let __v_74: G = __loaded[4];
+    let __v_75: G = __loaded[5];
+    let __v_76: G = __loaded[6];
+    let __v_77: G = __loaded[7];
+    let __v_78: G = __loaded[8];
+    let __v_79: G = __loaded[9];
+    let __v_80: G = __loaded[10];
+    let __v_81: G = __loaded[11];
+    let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_70.as_canonical_u64() {
   5u64 => {
-    break '__mc_1 [__v_74];
+    break '__mc_1 [__v_73];
   },
   _ => {
-    let __v_83: G = G::from_u64(0);
-    break '__mc_1 [__v_83];
+    let __v_82: G = G::from_u64(0);
+    break '__mc_1 [__v_82];
   },
 }
  };
-    let __v_83: G = __mc_out___mc_1[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_69, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-    let __v_84: G = __r_arr[0];
-    match __v_84.as_canonical_u64() {
+    let __v_82: G = __mc_out___mc_1[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_68, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __v_83: G = __r_arr[0];
+    match __v_83.as_canonical_u64() {
       1u64 => {
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __v_85: G = G::from_u64(1);
-            break '__mc_0 [__v_85];
+            let __v_84: G = G::from_u64(1);
+            break '__mc_0 [__v_84];
           },
           _ => {
-            let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; 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_585] = { let __args: [G; IN_585] = [__v_58, __v_59, __v_61, __v_62, __v_60, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } };
+            let __v_84: G = __r_arr[0];
+            let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_84, __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_85: G = __r_arr[0];
-            let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_85, __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_86: G = __r_arr[0];
-            break '__mc_0 [__v_86];
+            break '__mc_0 [__v_85];
           },
         }
       },
       _ => {
-        let __v_85: G = G::from_u64(0);
-        break '__mc_0 [__v_85];
+        let __v_84: G = G::from_u64(0);
+        break '__mc_0 [__v_84];
       },
     }
   },
   _ => {
-    let __v_69: G = G::from_u64(0);
-    break '__mc_0 [__v_69];
+    let __v_68: G = G::from_u64(0);
+    break '__mc_0 [__v_68];
   },
 }
  };
-            let __v_69: G = __mc_out___mc_0[0];
-            match __v_69.as_canonical_u64() {
+            let __v_68: G = __mc_out___mc_0[0];
+            match __v_68.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_630] = [__v_55];
+                let __ret: [G; OUT_630] = [__v_54];
                 record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_70: G = G::from_u64(1);
-                let __v_71: G = (__v_7 + __v_70);
-                let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_72: G = __r_arr[0];
-                let __ret: [G; OUT_630] = [__v_72];
+                let __v_69: G = G::from_u64(1);
+                let __v_70: G = (__v_7 + __v_69);
+                let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_6, __v_70]; 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_71: G = __r_arr[0];
+                let __ret: [G; OUT_630] = [__v_71];
                 record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __v_55: G = G::from_u64(1);
-            let __v_56: G = (__v_7 + __v_55);
-            let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_57: G = __r_arr[0];
-            let __ret: [G; OUT_630] = [__v_57];
+            let __v_54: G = G::from_u64(1);
+            let __v_55: G = (__v_7 + __v_54);
+            let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_6, __v_55]; 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_56: G = __r_arr[0];
+            let __ret: [G; OUT_630] = [__v_56];
             record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-      },
     }
   })
 }
@@ -53984,60 +53104,53 @@ fn aiur_fn_631(
 ) -> Result<[G; OUT_631], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_7: G = G::from_u64(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_631] = [__v_9];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_631] = [__v_1];
         record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-        let __v_8: G = __loaded[0];
-        let __v_9: G = __loaded[1];
-        let __v_10: G = __loaded[2];
-        let __v_11: G = __loaded[3];
-        let __v_12: G = __loaded[4];
-        let __v_13: G = __loaded[5];
-        let __v_14: G = __loaded[6];
-        let __v_15: G = __loaded[7];
-        let __v_16: G = __loaded[8];
-        let __v_17: G = __loaded[9];
-        let __v_18: G = __loaded[10];
-        let __v_19: G = __loaded[11];
-        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() {
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_1]; 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 __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __v_12: G = __loaded[5];
+        let __v_13: G = __loaded[6];
+        let __v_14: G = __loaded[7];
+        let __v_15: G = __loaded[8];
+        let __v_16: G = __loaded[9];
+        let __v_17: G = __loaded[10];
+        let __v_18: G = __loaded[11];
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() {
   5u64 => {
-    break '__mc_0 [__v_11];
+    break '__mc_0 [__v_10];
   },
   _ => {
-    let __v_20: G = G::from_u64(0);
-    break '__mc_0 [__v_20];
+    let __v_19: G = G::from_u64(0);
+    break '__mc_0 [__v_19];
   },
 }
  };
-        let __v_20: G = __mc_out___mc_0[0];
-        let __v_21: G = G::from_u64(0);
-        let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6]; 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_22: G = __r_arr[0];
-        let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_631] = [__v_23];
+        let __v_19: G = __mc_out___mc_0[0];
+        let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5]; 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_20: G = __r_arr[0];
+        let __v_21: G = { let __values: [G; 2] = [__v_19, __v_20]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_631] = [__v_21];
         record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -54075,23 +53188,15 @@ fn aiur_fn_632(
     let __v_18: G = __r_arr[7];
     let __v_19: G = G::from_u64(4);
     let __v_20: G = G::from_u64(0);
-    let __v_21: G = G::from_u64(1);
-    let __v_22: G = G::from_u64(1);
-    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_24: G = G::from_u64(1);
-    let __v_25: G = G::from_u64(1);
-    let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_27: G = G::from_u64(1);
-    let __v_28: G = G::from_u64(1);
-    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_30: G = G::from_u64(1);
-    let __v_31: G = G::from_u64(1);
-    let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
-    let __v_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
-    let __v_34: G = __r_arr[0];
-    let __ret: [G; OUT_632] = [__v_34];
+    let __v_21: G = G::from_u64(0);
+    let __v_22: G = G::from_u64(0);
+    let __v_23: G = G::from_u64(0);
+    let __v_24: G = G::from_u64(0);
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_21, __v_22, __v_23, __v_24]; 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_25: G = __r_arr[0];
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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_26: G = __r_arr[0];
+    let __ret: [G; OUT_632] = [__v_26];
     record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -54125,17 +53230,15 @@ fn aiur_fn_633(
     let __v_15: G = (__v_12 - __v_14);
     match __v_15.as_canonical_u64() {
       0u64 => {
-        let __v_16: G = G::from_u64(1);
-        let __v_17: G = G::from_u64(1);
-        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_633] = [__v_18];
+        let __v_16: G = G::from_u64(0);
+        let __ret: [G; OUT_633] = [__v_16];
         record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_10, __v_11, __v_14]; 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_16: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_17: G = __loaded[0];
         let __v_18: G = __loaded[1];
         let __v_19: G = __loaded[2];
@@ -54154,15 +53257,14 @@ fn aiur_fn_633(
             let __v_29: G = __r_arr[0];
             let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_30: G = __r_arr[0];
-            let __v_31: G = G::from_u64(0);
-            let __v_32: G = G::from_u64(1);
-            let __v_33: G = (__v_13 + __v_32);
-            let __v_34: G = G::from_u64(1);
-            let __v_35: G = (__v_14 + __v_34);
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } };
-            let __v_36: G = __r_arr[0];
-            let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_633] = [__v_37];
+            let __v_31: G = G::from_u64(1);
+            let __v_32: G = (__v_13 + __v_31);
+            let __v_33: G = G::from_u64(1);
+            let __v_34: G = (__v_14 + __v_33);
+            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_32, __v_34]; 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_35: G = __r_arr[0];
+            let __v_36: G = { let __values: [G; 2] = [__v_30, __v_35]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_633] = [__v_36];
             record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -54218,70 +53320,64 @@ fn aiur_fn_635(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-    let __v_8: G = __loaded[0];
-    let __v_9: G = __loaded[1];
-    let __v_10: G = __loaded[2];
-    let __v_11: G = __loaded[3];
-    let __v_12: G = __loaded[4];
-    let __v_13: G = __loaded[5];
-    match __v_8.as_canonical_u64() {
-      1u64 => {
-        let __v_14: G = G::from_u64(1);
-        let __v_15: G = G::from_u64(1);
-        let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_635] = [__v_16];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_635] = [__v_8];
         record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-        let __v_15: G = __loaded[0];
-        let __v_16: G = __loaded[1];
-        let __v_17: G = __loaded[2];
-        let __v_18: G = __loaded[3];
-        let __v_19: G = __loaded[4];
-        let __v_20: G = __loaded[5];
-        let __v_21: G = __loaded[6];
-        let __v_22: G = __loaded[7];
-        let __v_23: G = __loaded[8];
-        let __v_24: G = __loaded[9];
-        let __v_25: G = __loaded[10];
-        let __v_26: G = __loaded[11];
-        match __v_15.as_canonical_u64() {
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_8: G = __loaded[0];
+        let __v_9: G = __loaded[1];
+        let __v_10: G = __loaded[2];
+        let __v_11: G = __loaded[3];
+        let __v_12: G = __loaded[4];
+        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __v_14: G = __loaded[0];
+        let __v_15: G = __loaded[1];
+        let __v_16: G = __loaded[2];
+        let __v_17: G = __loaded[3];
+        let __v_18: G = __loaded[4];
+        let __v_19: G = __loaded[5];
+        let __v_20: G = __loaded[6];
+        let __v_21: G = __loaded[7];
+        let __v_22: G = __loaded[8];
+        let __v_23: G = __loaded[9];
+        let __v_24: G = __loaded[10];
+        let __v_25: G = __loaded[11];
+        match __v_14.as_canonical_u64() {
           5u64 => {
-            let __v_27: G = G::from_u64(0);
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_26: G = G::from_u64(0);
+            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_8, __v_9, __v_10, __v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_21, __v_22, __v_19, __v_6, __v_26]; 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_27: G = __r_arr[0];
+            let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_27]; 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_28]; 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_29: G = __r_arr[0];
-            let __v_30: G = (__v_6 + __v_29);
-            let __v_31: G = G::from_u64(1);
-            let __v_32: G = (__v_7 + __v_31);
-            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_29: G = (__v_6 + __v_28);
+            let __v_30: G = G::from_u64(1);
+            let __v_31: G = (__v_7 + __v_30);
+            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_29, __v_31]; 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_32: G = __r_arr[0];
+            let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_27, __v_32]; 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_33: G = __r_arr[0];
-            let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_28, __v_33]; 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_34: G = __r_arr[0];
-            let __ret: [G; OUT_635] = [__v_34];
+            let __ret: [G; OUT_635] = [__v_33];
             record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_27: G = G::from_u64(1);
-            let __v_28: G = (__v_7 + __v_27);
-            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_29: G = __r_arr[0];
-            let __ret: [G; OUT_635] = [__v_29];
+            let __v_26: G = G::from_u64(1);
+            let __v_27: G = (__v_7 + __v_26);
+            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_27]; 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_28: G = __r_arr[0];
+            let __ret: [G; OUT_635] = [__v_28];
             record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-      },
     }
   })
 }
@@ -54308,18 +53404,18 @@ fn aiur_fn_636(
         let __v_7: G = (__v_1 - __v_6);
         let __v_8: G = (__v_7 - __v_0);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __ret: [G; OUT_636] = [__v_10];
         record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_4]; 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_734] = { let __args: [G; IN_734] = [__v_4]; 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_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_726] = { let __args: [G; IN_726] = [__v_4, __v_0]; 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_727] = { let __args: [G; IN_727] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __v_8: G = G::from_u64(0);
             let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_7, __v_2, __v_8]; 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)? } };
@@ -54334,7 +53430,7 @@ fn aiur_fn_636(
             let __v_9: G = (__v_1 - __v_8);
             let __v_10: G = (__v_9 - __v_0);
             let __v_11: G = G::from_u64(0);
-            let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __ret: [G; OUT_636] = [__v_12];
             record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -54357,7 +53453,7 @@ fn aiur_fn_637(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -54405,7 +53501,7 @@ fn aiur_fn_638(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -54428,35 +53524,33 @@ fn aiur_fn_638(
             return Ok(__ret);
           },
           _ => {
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = G::from_u64(1);
-            let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_13]; 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_14: G = __r_arr[0];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-            let __v_15: G = __loaded[0];
-            let __v_16: G = __loaded[1];
-            let __v_17: G = __loaded[2];
-            let __v_18: G = __loaded[3];
-            match __v_15.as_canonical_u64() {
+            let __v_11: G = G::from_u64(0);
+            let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_11]; 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_12: 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_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __v_13: G = __loaded[0];
+            let __v_14: G = __loaded[1];
+            let __v_15: G = __loaded[2];
+            let __v_16: G = __loaded[3];
+            match __v_13.as_canonical_u64() {
               5u64 => {
                 let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_6, __v_2, __v_3, __v_4, __v_5]; 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_17: G = __r_arr[0];
+                let __v_18: G = G::from_u64(0);
+                let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_15, __v_17, __v_18]; 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_19: G = __r_arr[0];
-                let __v_20: G = G::from_u64(0);
-                let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_17, __v_19, __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_20: G = G::from_u64(1);
+                let __v_21: G = (__v_1 - __v_20);
                 let __v_22: G = G::from_u64(1);
-                let __v_23: G = (__v_1 - __v_22);
-                let __v_24: G = G::from_u64(1);
-                let __v_25: G = (__v_6 + __v_24);
-                let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; 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_26: G = __r_arr[0];
-                let __ret: [G; OUT_638] = [__v_26];
+                let __v_23: G = (__v_6 + __v_22);
+                let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_19, __v_21, __v_2, __v_3, __v_4, __v_5, __v_23]; 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_24: G = __r_arr[0];
+                let __ret: [G; OUT_638] = [__v_24];
                 record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
               },
             }
           },
@@ -54497,63 +53591,57 @@ fn aiur_fn_639(
     let __v_17: G = G::from_u64(0);
     let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; 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_18: G = __r_arr[0];
-    let __v_19: G = G::from_u64(1);
-    let __v_20: G = G::from_u64(1);
-    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_22: G = G::from_u64(1);
-    let __v_23: G = G::from_u64(1);
-    let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_25: G = G::from_u64(1);
-    let __v_26: G = G::from_u64(1);
-    let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_28: G = G::from_u64(0);
-    let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
-    let __v_29: G = __r_arr[0];
-    let __v_30: G = __r_arr[1];
-    let __v_31: G = __r_arr[2];
-    let __v_32: G = __r_arr[3];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_29]; 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_19: G = G::from_u64(0);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = G::from_u64(0);
+    let __v_22: G = G::from_u64(0);
+    let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_18, __v_6, __v_19, __v_20, __v_21, __v_22, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
+    let __v_23: G = __r_arr[0];
+    let __v_24: G = __r_arr[1];
+    let __v_25: G = __r_arr[2];
+    let __v_26: G = __r_arr[3];
+    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_23]; 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_27: G = __r_arr[0];
+    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_24]; 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_28: G = __r_arr[0];
+    let __v_29: G = (__v_27 + __v_28);
+    let __v_30: G = (__v_15 + __v_29);
+    let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_26]; 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_31: G = __r_arr[0];
+    let __v_32: G = __r_arr[1];
+    let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_32, __v_2]; 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_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } };
-    let __v_34: G = __r_arr[0];
-    let __v_35: G = (__v_33 + __v_34);
-    let __v_36: G = (__v_15 + __v_35);
-    let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_32]; 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_37: G = __r_arr[0];
-    let __v_38: G = __r_arr[1];
-    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_38, __v_2]; 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_39: G = __r_arr[0];
+    let __v_34: G = G::from_u64(0);
+    let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_33, __v_28, __v_34]; 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_35: G = __r_arr[0];
+    let __v_36: G = G::from_u64(1);
+    let __v_37: G = (__v_30 - __v_36);
+    let __v_38: G = (__v_11 + __v_12);
+    let __v_39: G = (__v_37 - __v_38);
     let __v_40: G = G::from_u64(0);
-    let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_39, __v_34, __v_40]; 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_41: G = __r_arr[0];
-    let __v_42: G = G::from_u64(1);
-    let __v_43: G = (__v_36 - __v_42);
-    let __v_44: G = (__v_11 + __v_12);
-    let __v_45: G = (__v_43 - __v_44);
-    let __v_46: G = G::from_u64(0);
-    let __v_47: G = G::from_u64(0);
-    let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_48, __v_41]; 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_41: G = G::from_u64(0);
+    let __v_42: G = { let __values: [G; 4] = [__v_40, __v_39, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_42, __v_35]; 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_43: G = __r_arr[0];
+    let __v_44: G = G::from_u64(2);
+    let __v_45: G = G::from_u64(0);
+    let __v_46: G = { let __values: [G; 4] = [__v_44, __v_0, __v_5, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_46, __v_2, __v_8, __v_30, __v_3, __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_47: G = __r_arr[0];
+    let __v_48: G = G::from_u64(0);
+    let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_47, __v_27, __v_29, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } };
     let __v_49: G = __r_arr[0];
-    let __v_50: G = G::from_u64(2);
+    let __v_50: G = G::from_u64(3);
     let __v_51: G = G::from_u64(0);
-    let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_52, __v_2, __v_8, __v_36, __v_3, __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_53: G = __r_arr[0];
-    let __v_54: G = G::from_u64(0);
-    let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } };
+    let __v_52: G = { let __values: [G; 4] = [__v_50, __v_43, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_53: G = G::from_u64(0);
+    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_24, __v_25, __v_23, __v_7, __v_11, __v_27, __v_15, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } };
+    let __v_54: G = __r_arr[0];
+    let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_52, __v_54]; 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_55: G = __r_arr[0];
-    let __v_56: G = G::from_u64(3);
-    let __v_57: G = G::from_u64(0);
-    let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_59: G = G::from_u64(0);
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } };
-    let __v_60: G = __r_arr[0];
-    let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_58, __v_60]; 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_61: G = __r_arr[0];
-    let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_61, __v_29]; 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_62: G = __r_arr[0];
-    let __ret: [G; OUT_639] = [__v_62];
+    let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_55, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } };
+    let __v_56: G = __r_arr[0];
+    let __ret: [G; OUT_639] = [__v_56];
     record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -54570,15 +53658,13 @@ fn aiur_fn_640(
 ) -> Result<[G; OUT_640], 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_641] = { let __args: [G; IN_641] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = G::from_u64(0);
+    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_2]; 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_4: G = __r_arr[0];
-    let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_640] = [__v_6, __v_5];
+    let __ret: [G; OUT_640] = [__v_4, __v_3];
     record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -54596,19 +53682,18 @@ fn aiur_fn_641(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       5u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_641] = [__v_8, __v_9];
+        let __v_6: G = { let __values: [G; 2] = [__v_3, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __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 __v_7: G = __r_arr[0];
+        let __v_8: G = __r_arr[1];
+        let __ret: [G; OUT_641] = [__v_7, __v_8];
         record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -54639,88 +53724,79 @@ fn aiur_fn_642(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_8: G = __loaded[0];
-    let __v_9: G = __loaded[1];
-    let __v_10: G = __loaded[2];
-    match __v_8.as_canonical_u64() {
-      1u64 => {
-        let __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_642] = [__v_13];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_642] = [__v_8];
         record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_1, __v_7, __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 __v_12: G = __r_arr[0];
-        let __v_13: G = G::from_u64(0);
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_3, __v_12, __v_13]; 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_14: G = __r_arr[0];
-        let __v_15: G = (__v_5 + __v_7);
-        let __v_16: G = (__v_6 + __v_15);
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_2, __v_9]; 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_17: G = __r_arr[0];
-        let __v_18: G = (__v_5 - __v_9);
-        let __v_19: G = (__v_18 + __v_7);
-        let __v_20: G = G::from_u64(0);
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_17, __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 __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_8: G = __loaded[0];
+        let __v_9: G = __loaded[1];
+        let __v_10: G = G::from_u64(0);
+        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_1, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = G::from_u64(0);
+        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_3, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __v_14: G = (__v_5 + __v_7);
+        let __v_15: G = (__v_6 + __v_14);
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_2, __v_8]; 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_16: G = __r_arr[0];
+        let __v_17: G = (__v_5 - __v_8);
+        let __v_18: G = (__v_17 + __v_7);
+        let __v_19: G = G::from_u64(0);
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_16, __v_18, __v_19]; 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_20: G = __r_arr[0];
+        let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_20]; 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_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_21]; 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_22: G = __r_arr[0];
-        let __v_23: G = __r_arr[1];
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_22]; 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_24: G = __r_arr[0];
-        let __v_25: G = (__v_16 + __v_24);
-        let __v_26: G = G::from_u64(1);
-        let __v_27: G = (__v_25 - __v_26);
-        let __v_28: G = (__v_4 + __v_12);
-        let __v_29: G = (__v_27 - __v_28);
-        let __v_30: G = G::from_u64(1);
-        let __v_31: G = (__v_25 - __v_30);
-        let __v_32: G = (__v_6 + __v_9);
-        let __v_33: G = (__v_31 - __v_32);
-        let __v_34: G = G::from_u64(1);
-        let __v_35: G = G::from_u64(1);
-        let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_23, __v_36]; 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_22: G = __r_arr[1];
+        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_21]; 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_23: G = __r_arr[0];
+        let __v_24: G = (__v_15 + __v_23);
+        let __v_25: G = G::from_u64(1);
+        let __v_26: G = (__v_24 - __v_25);
+        let __v_27: G = (__v_4 + __v_11);
+        let __v_28: G = (__v_26 - __v_27);
+        let __v_29: G = G::from_u64(1);
+        let __v_30: G = (__v_24 - __v_29);
+        let __v_31: G = (__v_6 + __v_8);
+        let __v_32: G = (__v_30 - __v_31);
+        let __v_33: G = G::from_u64(0);
+        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_22, __v_33]; 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_34: G = __r_arr[0];
+        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_34]; 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_35: G = __r_arr[0];
+        let __v_36: G = __r_arr[1];
+        let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_36, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
-        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 __v_38: G = __r_arr[0];
-        let __v_39: G = __r_arr[1];
-        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_39, __v_14]; 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_40: G = __r_arr[0];
-        let __v_41: G = G::from_u64(0);
+        let __v_38: G = G::from_u64(0);
+        let __v_39: G = G::from_u64(0);
+        let __v_40: G = { let __values: [G; 4] = [__v_38, __v_28, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_40, __v_37]; 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_41: G = __r_arr[0];
         let __v_42: G = G::from_u64(0);
-        let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_43, __v_40]; 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_44: G = __r_arr[0];
+        let __v_43: G = G::from_u64(0);
+        let __v_44: G = { let __values: [G; 4] = [__v_42, __v_32, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_45: G = G::from_u64(0);
-        let __v_46: G = G::from_u64(0);
-        let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_44, __v_23, __v_45]; 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_46: G = __r_arr[0];
+        let __v_47: G = G::from_u64(3);
         let __v_48: G = G::from_u64(0);
-        let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_47, __v_24, __v_48]; 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_49: G = __r_arr[0];
-        let __v_50: G = G::from_u64(3);
-        let __v_51: G = G::from_u64(0);
-        let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_52, __v_22]; 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_49: G = { let __values: [G; 4] = [__v_47, __v_41, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_49, __v_21]; 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_50: G = __r_arr[0];
+        let __v_51: G = G::from_u64(1);
+        let __v_52: G = (__v_7 + __v_51);
+        let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } };
         let __v_53: G = __r_arr[0];
-        let __v_54: G = G::from_u64(0);
-        let __v_55: G = G::from_u64(1);
-        let __v_56: G = (__v_7 + __v_55);
-        let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } };
-        let __v_57: G = __r_arr[0];
-        let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_642] = [__v_58];
+        let __v_54: G = { let __values: [G; 2] = [__v_50, __v_53]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_642] = [__v_54];
         record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-      },
     }
   })
 }
@@ -54738,32 +53814,25 @@ fn aiur_fn_643(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_643] = [__v_8];
-        record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = { 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_643] = [__v_9];
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_643] = [__v_3];
         record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_4, __v_1, __v_2]; 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_6: G = __r_arr[0];
+        let __v_7: G = { let __values: [G; 2] = [__v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_643] = [__v_7];
+        record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -54796,10 +53865,10 @@ fn aiur_fn_644(
         let __v_7: G = (__v_2 - __v_6);
         let __v_8: G = (__v_7 - __v_3);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_11: G = G::from_u64(3);
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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() + 1); __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_644] = { let __args: [G; IN_644] = [__v_13, __v_1, __v_2, __v_15]; 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)? } };
@@ -54886,48 +53955,46 @@ fn aiur_fn_647(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __v_3: G = G::from_u64(1);
-    let __v_4: G = G::from_u64(1);
-    let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_5]; 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_6: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_7: G = __loaded[0];
-    let __v_8: G = __loaded[1];
-    let __v_9: G = __loaded[2];
-    let __v_10: G = __loaded[3];
-    match __v_7.as_canonical_u64() {
+    let __v_3: G = G::from_u64(0);
+    let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_5: G = __loaded[0];
+    let __v_6: G = __loaded[1];
+    let __v_7: G = __loaded[2];
+    let __v_8: G = __loaded[3];
+    match __v_5.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_647] = [__v_11, __v_12];
+        let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_7, __v_1, __v_2]; 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_9: G = __r_arr[0];
+        let __v_10: G = __r_arr[1];
+        let __ret: [G; OUT_647] = [__v_9, __v_10];
         record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        let __v_16: G = __loaded[3];
-        match __v_13.as_canonical_u64() {
+        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_11: G = __loaded[0];
+        let __v_12: G = __loaded[1];
+        let __v_13: G = __loaded[2];
+        let __v_14: G = __loaded[3];
+        match __v_11.as_canonical_u64() {
           2u64 => {
-            let __v_17: G = G::from_u64(0);
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_1, __v_14, __v_12, __v_2, __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 __v_18: G = __r_arr[0];
-            let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_647] = [__v_18, __v_19];
+            let __v_15: G = G::from_u64(0);
+            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_1, __v_12, __v_10, __v_2, __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 __v_16: G = __r_arr[0];
+            let __v_17: G = __r_arr[1];
+            let __ret: [G; OUT_647] = [__v_16, __v_17];
             record.function_queries[647].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_647] = [__v_17, __v_18];
+            let __v_15: G = G::from_u64(0);
+            let __v_16: G = G::from_u64(0);
+            let __ret: [G; OUT_647] = [__v_15, __v_16];
             record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -54952,60 +54019,56 @@ fn aiur_fn_648(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-    let __v_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    let __v_8: G = __loaded[3];
-    let __v_9: G = __loaded[4];
-    let __v_10: G = __loaded[5];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_648] = [__v_11, __v_12];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_648] = [__v_5, __v_6];
         record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() {
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        let __v_9: G = __loaded[4];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
   0u64 => {
-    let __v_12: G = G::from_u64(1);
-    break '__mc_0 [__v_12];
+    let __v_11: G = G::from_u64(1);
+    break '__mc_0 [__v_11];
   },
   _ => {
-    let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    break '__mc_0 [__v_12];
+    let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_7, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    break '__mc_0 [__v_11];
   },
 }
  };
-        let __v_12: G = __mc_out___mc_0[0];
-        let __v_13: G = (__v_11 * __v_12);
-        match __v_13.as_canonical_u64() {
+        let __v_11: G = __mc_out___mc_0[0];
+        let __v_12: G = (__v_10 * __v_11);
+        match __v_12.as_canonical_u64() {
           1u64 => {
-            let __v_14: G = G::from_u64(1);
-            let __ret: [G; OUT_648] = [__v_14, __v_4];
+            let __v_13: G = G::from_u64(1);
+            let __ret: [G; OUT_648] = [__v_13, __v_4];
             record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_14: G = G::from_u64(1);
-            let __v_15: G = (__v_4 + __v_14);
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_10, __v_1, __v_2, __v_3, __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 __v_16: G = __r_arr[0];
-            let __v_17: G = __r_arr[1];
-            let __ret: [G; OUT_648] = [__v_16, __v_17];
+            let __v_13: G = G::from_u64(1);
+            let __v_14: G = (__v_4 + __v_13);
+            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_9, __v_1, __v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } };
+            let __v_15: G = __r_arr[0];
+            let __v_16: G = __r_arr[1];
+            let __ret: [G; OUT_648] = [__v_15, __v_16];
             record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
     }
   })
 }
@@ -55023,59 +54086,51 @@ fn aiur_fn_649(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_649] = [__v_6];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_649] = [__v_3];
         record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_649] = [__v_9];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_5: G = G::from_u64(0);
+            let __ret: [G; OUT_649] = [__v_5];
             record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_2, __v_9]; 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_10, __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 __v_11: G = __r_arr[0];
-            match __v_11.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_5: G = __loaded[0];
+            let __v_6: G = __loaded[1];
+            let __v_7: G = G::from_u64(0);
+            let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_2, __v_7]; 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_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            match __v_9.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_5, __v_8, __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 __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_649] = [__v_12];
+                let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_4, __v_6, __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 __v_10: G = __r_arr[0];
+                let __ret: [G; OUT_649] = [__v_10];
                 record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_649] = [__v_12];
+                let __v_10: G = G::from_u64(0);
+                let __ret: [G; OUT_649] = [__v_10];
                 record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -55097,7 +54152,7 @@ fn aiur_fn_650(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_7: G = __loaded[0];
     let __v_8: G = __loaded[1];
     let __v_9: G = __loaded[2];
@@ -55108,45 +54163,42 @@ fn aiur_fn_650(
         let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_1, __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 __v_13: G = __r_arr[1];
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 3] = [__v_14, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_14: G = { let __values: [G; 2] = [__v_8, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __v_16: G = G::from_u64(0);
-            let __v_17: G = { let __values: [G; 3] = [__v_16, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_18: G = G::from_u64(0);
-            let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_20: G = G::from_u64(1);
-            let __v_21: G = (__v_5 + __v_20);
-            let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
-            let __v_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_650] = [__v_22, __v_23, __v_24, __v_25];
+            let __v_15: G = { let __values: [G; 2] = [__v_5, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_16: G = { let __values: [G; 2] = [__v_13, __v_4]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_17: G = G::from_u64(1);
+            let __v_18: G = (__v_5 + __v_17);
+            let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_9, __v_1, __v_14, __v_15, __v_16, __v_18, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
+            let __v_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 __ret: [G; OUT_650] = [__v_19, __v_20, __v_21, __v_22];
             record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_16: G = G::from_u64(1);
-            let __v_17: G = (__v_5 + __v_16);
-            let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
-            let __v_18: G = __r_arr[0];
-            let __v_19: G = __r_arr[1];
-            let __v_20: G = __r_arr[2];
-            let __v_21: G = __r_arr[3];
-            let __ret: [G; OUT_650] = [__v_18, __v_19, __v_20, __v_21];
+            let __v_15: G = G::from_u64(1);
+            let __v_16: G = (__v_5 + __v_15);
+            let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_9, __v_1, __v_14, __v_3, __v_4, __v_16, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
+            let __v_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 __ret: [G; OUT_650] = [__v_17, __v_18, __v_19, __v_20];
             record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_3]; 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_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_4]; 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_13: G = __r_arr[0];
         let __ret: [G; OUT_650] = [__v_11, __v_12, __v_13, __v_0];
         record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -55170,67 +54222,60 @@ fn aiur_fn_651(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    let __v_8: G = __loaded[4];
-    let __v_9: G = __loaded[5];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __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_651] = [__v_12];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_651] = [__v_4];
         record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-        let __v_11: G = __loaded[0];
-        let __v_12: G = __loaded[1];
-        let __v_13: G = __loaded[2];
-        let __v_14: G = __loaded[3];
-        let __v_15: G = __loaded[4];
-        let __v_16: G = __loaded[5];
-        let __v_17: G = __loaded[6];
-        let __v_18: G = __loaded[7];
-        let __v_19: G = __loaded[8];
-        let __v_20: G = __loaded[9];
-        let __v_21: G = __loaded[10];
-        let __v_22: G = __loaded[11];
-        match __v_11.as_canonical_u64() {
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        let __v_8: G = __loaded[4];
+        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __v_10: G = __loaded[0];
+        let __v_11: G = __loaded[1];
+        let __v_12: G = __loaded[2];
+        let __v_13: G = __loaded[3];
+        let __v_14: G = __loaded[4];
+        let __v_15: G = __loaded[5];
+        let __v_16: G = __loaded[6];
+        let __v_17: G = __loaded[7];
+        let __v_18: G = __loaded[8];
+        let __v_19: G = __loaded[9];
+        let __v_20: G = __loaded[10];
+        let __v_21: G = __loaded[11];
+        match __v_10.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_23: G = __r_arr[0];
-            let __v_24: G = G::from_u64(0);
-            let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_23, __v_3, __v_24]; 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_25: G = __r_arr[0];
-            let __v_26: G = G::from_u64(0);
-            let __v_27: G = G::from_u64(1);
-            let __v_28: G = (__v_3 + __v_27);
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_9, __v_1, __v_2, __v_28]; 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_29: G = __r_arr[0];
-            let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_651] = [__v_30];
+            let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_4, __v_12, __v_13, __v_14, __v_7, __v_1, __v_2, __v_5, __v_6]; 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_22: G = __r_arr[0];
+            let __v_23: G = G::from_u64(0);
+            let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_22, __v_3, __v_23]; 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_24: G = __r_arr[0];
+            let __v_25: G = G::from_u64(1);
+            let __v_26: G = (__v_3 + __v_25);
+            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_8, __v_1, __v_2, __v_26]; 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_27: G = __r_arr[0];
+            let __v_28: G = { let __values: [G; 2] = [__v_24, __v_27]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_651] = [__v_28];
             record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_9, __v_1, __v_2, __v_3]; 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_23: G = __r_arr[0];
-            let __ret: [G; OUT_651] = [__v_23];
+            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_8, __v_1, __v_2, __v_3]; 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_22: G = __r_arr[0];
+            let __ret: [G; OUT_651] = [__v_22];
             record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
     }
   })
 }
@@ -55264,7 +54309,7 @@ fn aiur_fn_652(
         let __v_13: G = __r_arr[0];
         let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_15: G = __loaded[0];
         let __v_16: G = __loaded[1];
         let __v_17: G = __loaded[2];
@@ -55319,7 +54364,7 @@ fn aiur_fn_652(
             let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_42: G = __r_arr[0];
             let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_736] = { let __args: [G; IN_736] = [__v_7]; 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_737] = { let __args: [G; IN_737] = [__v_7]; 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_43: G = __r_arr[0];
             if (__v_43 != __v_20) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursor rule count differs from the inductive's ctor count".to_string()) });
@@ -55365,7 +54410,7 @@ fn aiur_fn_653(
     let __v_8: G = (__v_1 + __v_7);
     let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_8]; 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_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_10: G = __loaded[0];
     let __v_11: G = __loaded[1];
     let __v_12: G = __loaded[2];
@@ -55375,7 +54420,7 @@ fn aiur_fn_653(
         let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_15]; 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_734] = { let __args: [G; IN_734] = [__v_15]; 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_16: G = __r_arr[0];
         if (__v_16 != __v_5) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("recursor major premise has the wrong number of spine args".to_string()) });
@@ -55406,24 +54451,21 @@ fn aiur_fn_654(
     let __v_2: G = (__v_0 - __v_1);
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_654] = [__v_5];
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_654] = [__v_3];
         record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_3: G = G::from_u64(0);
-        let __v_4: G = G::from_u64(4);
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = (__v_1 + __v_7);
-        let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-        let __v_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_654] = [__v_10];
+        let __v_3: G = G::from_u64(4);
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_1, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_1 + __v_6);
+        let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __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 __v_8: G = __r_arr[0];
+        let __v_9: G = { let __values: [G; 2] = [__v_5, __v_8]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_654] = [__v_9];
         record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -55444,33 +54486,29 @@ fn aiur_fn_655(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_655] = [];
         record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_4.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        match __v_3.as_canonical_u64() {
           _ => {
-            let __v_8: G = (__v_1 + __v_5);
-            let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_7, __v_1, __v_2]; 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_7: G = (__v_1 + __v_4);
+            let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_5, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
             let __ret: [G; OUT_655] = [];
             record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -55496,7 +54534,7 @@ fn aiur_fn_656(
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_4: G = __loaded[0];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -55507,13 +54545,12 @@ fn aiur_fn_656(
             let __v_9: G = (__v_1 - __v_8);
             let __v_10: G = G::from_u64(1);
             let __v_11: G = (__v_2 + __v_10);
-            let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = __r_arr[1];
-            let __v_16: G = __r_arr[2];
-            let __ret: [G; OUT_656] = [__v_14, __v_15, __v_16];
+            let __v_12: G = { let __values: [G; 2] = [__v_5, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_6, __v_9, __v_11, __v_12]; 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_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            let __v_15: G = __r_arr[2];
+            let __ret: [G; OUT_656] = [__v_13, __v_14, __v_15];
             record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -55557,11 +54594,9 @@ fn aiur_fn_657(
       0u64 => {
         let __v_14: G = G::from_u64(0);
         let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
-        let __v_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_457] = { let __args: [G; IN_457] = [__v_2, __v_17]; 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_18: G = __r_arr[0];
+        let __v_15: G = G::from_u64(0);
+        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
         let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_13, __v_2]; 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 __ret: [G; OUT_657] = [];
         record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -55572,17 +54607,13 @@ fn aiur_fn_657(
         let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
         let __v_15: G = G::from_u64(0);
         let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
-        let __v_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_457] = { let __args: [G; IN_457] = [__v_2, __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 __v_19: G = __r_arr[0];
+        let __v_16: G = G::from_u64(0);
+        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_2, __v_16]; 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_17: G = __r_arr[0];
         let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_13, __v_2]; 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_538] = { let __args: [G; IN_538] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } };
-        let __v_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_458] = { let __args: [G; IN_458] = [__v_3, __v_2, __v_22]; 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_18: G = G::from_u64(0);
+        let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_2, __v_18]; 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 __ret: [G; OUT_657] = [];
         record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -55592,26 +54623,22 @@ fn aiur_fn_657(
         let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
         let __v_15: G = G::from_u64(0);
         let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
-        let __v_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_457] = { let __args: [G; IN_457] = [__v_2, __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 __v_19: G = __r_arr[0];
+        let __v_16: G = G::from_u64(0);
+        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_2, __v_16]; 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_17: G = __r_arr[0];
         let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_13, __v_2]; 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_538] = { let __args: [G; IN_538] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = G::from_u64(0);
-        let __v_21: G = G::from_u64(0);
-        let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_19, __v_22]; 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_23: G = __r_arr[0];
-        let __v_24: G = G::from_u64(1);
-        if (__v_23 != __v_24) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("theorem's type is not a Prop".to_string()) });
+        let __v_18: G = G::from_u64(0);
+        let __v_19: G = G::from_u64(0);
+        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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_17, __v_20]; 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_21: G = __r_arr[0];
+        let __v_22: G = G::from_u64(1);
+        if (__v_21 != __v_22) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("theorem's type is not a Prop".to_string()) });
         }
-        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_458] = { let __args: [G; IN_458] = [__v_3, __v_2, __v_27]; 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_23: G = G::from_u64(0);
+        let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_2, __v_23]; 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 __ret: [G; OUT_657] = [];
         record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -55621,17 +54648,13 @@ fn aiur_fn_657(
         let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
         let __v_15: G = G::from_u64(0);
         let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
-        let __v_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_457] = { let __args: [G; IN_457] = [__v_2, __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 __v_19: G = __r_arr[0];
+        let __v_16: G = G::from_u64(0);
+        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_2, __v_16]; 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_17: G = __r_arr[0];
         let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_13, __v_2]; 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_538] = { let __args: [G; IN_538] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } };
-        let __v_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_458] = { let __args: [G; IN_458] = [__v_3, __v_2, __v_22]; 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_18: G = G::from_u64(0);
+        let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_2, __v_18]; 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 __ret: [G; OUT_657] = [];
         record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -55639,11 +54662,9 @@ fn aiur_fn_657(
       4u64 => {
         let __v_14: G = G::from_u64(0);
         let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
-        let __v_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_457] = { let __args: [G; IN_457] = [__v_2, __v_17]; 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_18: G = __r_arr[0];
+        let __v_15: G = G::from_u64(0);
+        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
         let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_13, __v_2]; 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_545] = { let __args: [G; IN_545] = [__v_12, __v_3, __v_1, __v_2]; 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 __ret: [G; OUT_657] = [];
@@ -55653,11 +54674,9 @@ fn aiur_fn_657(
       5u64 => {
         let __v_14: G = G::from_u64(0);
         let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
-        let __v_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_457] = { let __args: [G; IN_457] = [__v_2, __v_17]; 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_18: G = __r_arr[0];
+        let __v_15: G = G::from_u64(0);
+        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
         let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_13, __v_2]; 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_535] = { let __args: [G; IN_535] = [__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_569] = { let __args: [G; IN_569] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } };
@@ -55669,62 +54688,54 @@ fn aiur_fn_657(
       6u64 => {
         let __v_14: G = G::from_u64(0);
         let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
-        let __v_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_457] = { let __args: [G; IN_457] = [__v_2, __v_17]; 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_18: G = __r_arr[0];
+        let __v_15: G = G::from_u64(0);
+        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
         let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_13, __v_2]; 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_263] = { let __args: [G; IN_263] = [__v_3, __v_4]; 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_19: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
-        let __v_20: G = __loaded[0];
-        let __v_21: G = __loaded[1];
-        let __v_22: G = __loaded[2];
-        let __v_23: G = __loaded[3];
-        let __v_24: G = __loaded[4];
-        let __v_25: G = __loaded[5];
-        let __v_26: G = __loaded[6];
-        let __v_27: G = __loaded[7];
-        let __v_28: G = __loaded[8];
-        let __v_29: G = __loaded[9];
-        let __v_30: G = __loaded[10];
-        let __v_31: G = __loaded[11];
-        match __v_20.as_canonical_u64() {
+        let __v_17: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __v_18: G = __loaded[0];
+        let __v_19: G = __loaded[1];
+        let __v_20: G = __loaded[2];
+        let __v_21: G = __loaded[3];
+        let __v_22: G = __loaded[4];
+        let __v_23: G = __loaded[5];
+        let __v_24: G = __loaded[6];
+        let __v_25: G = __loaded[7];
+        let __v_26: G = __loaded[8];
+        let __v_27: G = __loaded[9];
+        let __v_28: G = __loaded[10];
+        let __v_29: G = __loaded[11];
+        match __v_18.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_22, __v_2, __v_23]; 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_550] = { let __args: [G; IN_550] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __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_32: G = (__v_23 + __v_24);
-            let __v_33: G = G::from_u64(1);
-            let __v_34: G = G::from_u64(1);
-            let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_22, __v_32, __v_35]; 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_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_6, __v_36]; 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)? } };
-            if (__v_6 != __v_23) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("ctor parameter count differs from its inductive's".to_string()) });
+            let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_20, __v_2, __v_21]; 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_550] = { let __args: [G; IN_550] = [__v_2, __v_6, __v_22, __v_7, __v_19, __v_3, __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_30: G = (__v_21 + __v_22);
+            let __v_31: G = G::from_u64(0);
+            let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_20, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } };
+            let __v_32: G = __r_arr[0];
+            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_6, __v_32]; 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)? } };
+            if (__v_6 != __v_21) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("ctor parameter count differs from its inductive's".to_string()) });
             }
-            let __v_37: G = G::from_u64(1);
-            let __v_38: G = G::from_u64(1);
-            let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_2, __v_6, __v_3, __v_39]; 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 = G::from_u64(0);
+            let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_2, __v_6, __v_3, __v_33]; 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 __ret: [G; OUT_657] = [];
             record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
           },
         }
       },
       7u64 => {
         let __v_14: G = G::from_u64(0);
         let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
-        let __v_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_457] = { let __args: [G; IN_457] = [__v_2, __v_17]; 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_18: G = __r_arr[0];
+        let __v_15: G = G::from_u64(0);
+        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
         let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_13, __v_2]; 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_535] = { let __args: [G; IN_535] = [__v_10]; 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_652] = { let __args: [G; IN_652] = [__v_0, __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[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)? } };
@@ -55752,7 +54763,7 @@ fn aiur_fn_658(
     let __v_0: G = inp[0];
     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; 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_1: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -55783,7 +54794,7 @@ fn aiur_fn_659(
 ) -> Result<[G; OUT_659], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -55804,25 +54815,21 @@ fn aiur_fn_659(
     let __v_18: G = __loaded[17];
     match __v_1.as_canonical_u64() {
       2u64 => {
-        let __v_19: G = G::from_u64(0);
         let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __v_21: G = G::from_u64(1);
-        let __v_22: G = G::from_u64(1);
-        let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_659] = [__v_24];
+        let __v_19: G = __r_arr[0];
+        let __v_20: G = G::from_u64(0);
+        let __v_21: G = { let __values: [G; 2] = [__v_19, __v_20]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_659] = [__v_21];
         record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __v_19: G = G::from_u64(0);
         let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
+        let __v_19: G = __r_arr[0];
         let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-        let __v_21: G = __r_arr[0];
-        let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_659] = [__v_22];
+        let __v_20: G = __r_arr[0];
+        let __v_21: G = { let __values: [G; 2] = [__v_19, __v_20]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_659] = [__v_21];
         record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -55831,7 +54838,7 @@ fn aiur_fn_659(
         let __v_19: G = __r_arr[0];
         let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_19, __v_20]; 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_725] = { let __args: [G; IN_725] = [__v_19, __v_20]; 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_21: G = __r_arr[0];
         let __ret: [G; OUT_659] = [__v_21];
         record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -55842,7 +54849,7 @@ fn aiur_fn_659(
         let __v_19: G = __r_arr[0];
         let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_19, __v_20]; 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_725] = { let __args: [G; IN_725] = [__v_19, __v_20]; 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_21: G = __r_arr[0];
         let __ret: [G; OUT_659] = [__v_21];
         record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -55853,7 +54860,7 @@ fn aiur_fn_659(
         let __v_19: G = __r_arr[0];
         let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_19, __v_20]; 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_725] = { let __args: [G; IN_725] = [__v_19, __v_20]; 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_21: G = __r_arr[0];
         let __ret: [G; OUT_659] = [__v_21];
         record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -55866,19 +54873,17 @@ fn aiur_fn_659(
         let __v_20: G = __r_arr[0];
         let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_21]; 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_725] = { let __args: [G; IN_725] = [__v_20, __v_21]; 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_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_19, __v_22]; 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_725] = { let __args: [G; IN_725] = [__v_19, __v_22]; 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_23: G = __r_arr[0];
         let __ret: [G; OUT_659] = [__v_23];
         record.function_queries[659].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; 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_659] = [__v_21];
+        let __v_19: G = G::from_u64(0);
+        let __ret: [G; OUT_659] = [__v_19];
         record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -55897,33 +54902,27 @@ fn aiur_fn_660(
 ) -> Result<[G; OUT_660], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_660] = [__v_6];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_660] = [__v_1];
         record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__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_3: G = __r_arr[0];
+        let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__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_725] = { let __args: [G; IN_725] = [__v_3, __v_4]; 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_660] = [__v_6];
+        let __ret: [G; OUT_660] = [__v_5];
         record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -55939,45 +54938,39 @@ fn aiur_fn_661(
 ) -> Result<[G; OUT_661], 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 };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    let __v_11: G = __loaded[10];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_661] = [__v_14];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_661] = [__v_1];
         record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_2.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __v_10: G = __loaded[9];
+        match __v_1.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10]; 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_659] = { let __args: [G; IN_659] = [__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 __v_11: G = __r_arr[0];
+            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__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_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_11]; 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_725] = { let __args: [G; IN_725] = [__v_11, __v_12]; 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_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_13]; 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_14: G = __r_arr[0];
-            let __ret: [G; OUT_661] = [__v_14];
+            let __ret: [G; OUT_661] = [__v_13];
             record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -55993,70 +54986,64 @@ fn aiur_fn_662(
 ) -> Result<[G; OUT_662], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    let __v_11: G = __loaded[10];
-    let __v_12: G = __loaded[11];
-    let __v_13: G = __loaded[12];
-    let __v_14: G = __loaded[13];
-    let __v_15: G = __loaded[14];
-    let __v_16: G = __loaded[15];
-    let __v_17: G = __loaded[16];
-    let __v_18: G = __loaded[17];
-    let __v_19: G = __loaded[18];
-    let __v_20: G = __loaded[19];
-    let __v_21: G = __loaded[20];
-    let __v_22: G = __loaded[21];
-    let __v_23: G = __loaded[22];
-    let __v_24: G = __loaded[23];
-    let __v_25: G = __loaded[24];
-    let __v_26: G = __loaded[25];
-    let __v_27: G = __loaded[26];
-    let __v_28: G = __loaded[27];
-    let __v_29: G = __loaded[28];
-    let __v_30: G = __loaded[29];
-    let __v_31: G = __loaded[30];
-    let __v_32: G = __loaded[31];
-    let __v_33: G = __loaded[32];
-    let __v_34: G = __loaded[33];
-    let __v_35: G = __loaded[34];
-    let __v_36: G = __loaded[35];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_37: G = G::from_u64(1);
-        let __v_38: G = G::from_u64(1);
-        let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_662] = [__v_39];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_662] = [__v_1];
         record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_2.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 35] = { let __mq = record.memory_queries.get_mut(&35).ok_or(ExecError::InvalidMemorySize(35))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 35 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 35] = __args[..35].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __v_10: G = __loaded[9];
+        let __v_11: G = __loaded[10];
+        let __v_12: G = __loaded[11];
+        let __v_13: G = __loaded[12];
+        let __v_14: G = __loaded[13];
+        let __v_15: G = __loaded[14];
+        let __v_16: G = __loaded[15];
+        let __v_17: G = __loaded[16];
+        let __v_18: G = __loaded[17];
+        let __v_19: G = __loaded[18];
+        let __v_20: G = __loaded[19];
+        let __v_21: G = __loaded[20];
+        let __v_22: G = __loaded[21];
+        let __v_23: G = __loaded[22];
+        let __v_24: G = __loaded[23];
+        let __v_25: G = __loaded[24];
+        let __v_26: G = __loaded[25];
+        let __v_27: G = __loaded[26];
+        let __v_28: G = __loaded[27];
+        let __v_29: G = __loaded[28];
+        let __v_30: G = __loaded[29];
+        let __v_31: G = __loaded[30];
+        let __v_32: G = __loaded[31];
+        let __v_33: G = __loaded[32];
+        let __v_34: G = __loaded[33];
+        let __v_35: G = __loaded[34];
+        match __v_1.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_35]; 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_659] = { let __args: [G; IN_659] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
+            let __v_36: G = __r_arr[0];
+            let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_35]; 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_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_36]; 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_725] = { let __args: [G; IN_725] = [__v_36, __v_37]; 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_38: G = __r_arr[0];
-            let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_37, __v_38]; 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_39: G = __r_arr[0];
-            let __ret: [G; OUT_662] = [__v_39];
+            let __ret: [G; OUT_662] = [__v_38];
             record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -56072,130 +55059,124 @@ fn aiur_fn_663(
 ) -> Result<[G; OUT_663], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    let __v_11: G = __loaded[10];
-    let __v_12: G = __loaded[11];
-    let __v_13: G = __loaded[12];
-    let __v_14: G = __loaded[13];
-    let __v_15: G = __loaded[14];
-    let __v_16: G = __loaded[15];
-    let __v_17: G = __loaded[16];
-    let __v_18: G = __loaded[17];
-    let __v_19: G = __loaded[18];
-    let __v_20: G = __loaded[19];
-    let __v_21: G = __loaded[20];
-    let __v_22: G = __loaded[21];
-    let __v_23: G = __loaded[22];
-    let __v_24: G = __loaded[23];
-    let __v_25: G = __loaded[24];
-    let __v_26: G = __loaded[25];
-    let __v_27: G = __loaded[26];
-    let __v_28: G = __loaded[27];
-    let __v_29: G = __loaded[28];
-    let __v_30: G = __loaded[29];
-    let __v_31: G = __loaded[30];
-    let __v_32: G = __loaded[31];
-    let __v_33: G = __loaded[32];
-    let __v_34: G = __loaded[33];
-    let __v_35: G = __loaded[34];
-    let __v_36: G = __loaded[35];
-    let __v_37: G = __loaded[36];
-    let __v_38: G = __loaded[37];
-    let __v_39: G = __loaded[38];
-    let __v_40: G = __loaded[39];
-    let __v_41: G = __loaded[40];
-    let __v_42: G = __loaded[41];
-    let __v_43: G = __loaded[42];
-    let __v_44: G = __loaded[43];
-    let __v_45: G = __loaded[44];
-    let __v_46: G = __loaded[45];
-    let __v_47: G = __loaded[46];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_48: G = G::from_u64(1);
-        let __v_49: G = G::from_u64(1);
-        let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_663] = [__v_50];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_663] = [__v_1];
         record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_2.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __v_10: G = __loaded[9];
+        let __v_11: G = __loaded[10];
+        let __v_12: G = __loaded[11];
+        let __v_13: G = __loaded[12];
+        let __v_14: G = __loaded[13];
+        let __v_15: G = __loaded[14];
+        let __v_16: G = __loaded[15];
+        let __v_17: G = __loaded[16];
+        let __v_18: G = __loaded[17];
+        let __v_19: G = __loaded[18];
+        let __v_20: G = __loaded[19];
+        let __v_21: G = __loaded[20];
+        let __v_22: G = __loaded[21];
+        let __v_23: G = __loaded[22];
+        let __v_24: G = __loaded[23];
+        let __v_25: G = __loaded[24];
+        let __v_26: G = __loaded[25];
+        let __v_27: G = __loaded[26];
+        let __v_28: G = __loaded[27];
+        let __v_29: G = __loaded[28];
+        let __v_30: G = __loaded[29];
+        let __v_31: G = __loaded[30];
+        let __v_32: G = __loaded[31];
+        let __v_33: G = __loaded[32];
+        let __v_34: G = __loaded[33];
+        let __v_35: G = __loaded[34];
+        let __v_36: G = __loaded[35];
+        let __v_37: G = __loaded[36];
+        let __v_38: G = __loaded[37];
+        let __v_39: G = __loaded[38];
+        let __v_40: G = __loaded[39];
+        let __v_41: G = __loaded[40];
+        let __v_42: G = __loaded[41];
+        let __v_43: G = __loaded[42];
+        let __v_44: G = __loaded[43];
+        let __v_45: G = __loaded[44];
+        let __v_46: G = __loaded[45];
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            match __v_3.as_canonical_u64() {
+            match __v_2.as_canonical_u64() {
               _ => {
+                let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
+                let __v_47: G = __r_arr[0];
                 let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
                 let __v_48: G = __r_arr[0];
-                let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_14]; 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_725] = { let __args: [G; IN_725] = [__v_47, __v_48]; 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_48, __v_49]; 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_663] = { let __args: [G; IN_663] = [__v_46]; 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_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_47]; 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_725] = { let __args: [G; IN_725] = [__v_49, __v_50]; 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_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_50, __v_51]; 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_52: G = __r_arr[0];
-                let __ret: [G; OUT_663] = [__v_52];
+                let __ret: [G; OUT_663] = [__v_51];
                 record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           1u64 => {
-            match __v_3.as_canonical_u64() {
+            match __v_2.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_28]; 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_659] = { let __args: [G; IN_659] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
+                let __v_47: G = __r_arr[0];
+                let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_28]; 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_48: G = __r_arr[0];
-                let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_29]; 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_725] = { let __args: [G; IN_725] = [__v_47, __v_48]; 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_48, __v_49]; 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_663] = { let __args: [G; IN_663] = [__v_46]; 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_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_47]; 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_725] = { let __args: [G; IN_725] = [__v_49, __v_50]; 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_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_50, __v_51]; 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_52: G = __r_arr[0];
-                let __ret: [G; OUT_663] = [__v_52];
+                let __ret: [G; OUT_663] = [__v_51];
                 record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           2u64 => {
-            match __v_3.as_canonical_u64() {
+            match __v_2.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
+                let __v_47: G = __r_arr[0];
+                let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_45]; 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_48: G = __r_arr[0];
-                let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_46]; 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_725] = { let __args: [G; IN_725] = [__v_47, __v_48]; 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_48, __v_49]; 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_663] = { let __args: [G; IN_663] = [__v_46]; 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_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_47]; 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_725] = { let __args: [G; IN_725] = [__v_49, __v_50]; 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_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_50, __v_51]; 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_52: G = __r_arr[0];
-                let __ret: [G; OUT_663] = [__v_52];
+                let __ret: [G; OUT_663] = [__v_51];
                 record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -56270,9 +55251,9 @@ fn aiur_fn_664(
                 let __v_49: G = __r_arr[0];
                 let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
                 let __v_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_49, __v_50]; 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_725] = { let __args: [G; IN_725] = [__v_49, __v_50]; 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_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_48, __v_51]; 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_725] = { let __args: [G; IN_725] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } };
                 let __v_52: G = __r_arr[0];
                 let __ret: [G; OUT_664] = [__v_52];
                 record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -56287,9 +55268,9 @@ fn aiur_fn_664(
                 let __v_49: G = __r_arr[0];
                 let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_44]; 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_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_49, __v_50]; 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_725] = { let __args: [G; IN_725] = [__v_49, __v_50]; 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_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_48, __v_51]; 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_725] = { let __args: [G; IN_725] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } };
                 let __v_52: G = __r_arr[0];
                 let __ret: [G; OUT_664] = [__v_52];
                 record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -56302,7 +55283,7 @@ fn aiur_fn_664(
               _ => {
                 let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
                 let __v_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_48, __v_49]; 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_725] = { let __args: [G; IN_725] = [__v_48, __v_49]; 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_50: G = __r_arr[0];
                 let __ret: [G; OUT_664] = [__v_50];
                 record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -56315,7 +55296,7 @@ fn aiur_fn_664(
               _ => {
                 let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
                 let __v_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_48, __v_49]; 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_725] = { let __args: [G; IN_725] = [__v_48, __v_49]; 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_50: G = __r_arr[0];
                 let __ret: [G; OUT_664] = [__v_50];
                 record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -56326,7 +55307,7 @@ fn aiur_fn_664(
           8u64 => {
             let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_1]; 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_49: G = __r_arr[0];
-            let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_48, __v_49]; 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_725] = { let __args: [G; IN_725] = [__v_48, __v_49]; 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_50: G = __r_arr[0];
             let __ret: [G; OUT_664] = [__v_50];
             record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -56355,38 +55336,34 @@ fn aiur_fn_665(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_665] = [__v_5];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_665] = [__v_2];
         record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_5: G = (__v_3 - __v_1);
-        match __v_5.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = (__v_2 - __v_1);
+        match __v_4.as_canonical_u64() {
           0u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_665] = [__v_6];
+            let __v_5: G = G::from_u64(1);
+            let __ret: [G; OUT_665] = [__v_5];
             record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_4, __v_1]; 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_665] = [__v_6];
+            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
+            let __v_5: G = __r_arr[0];
+            let __ret: [G; OUT_665] = [__v_5];
             record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -56526,22 +55503,21 @@ fn aiur_fn_667(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_667] = [];
         record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
         let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_6.as_canonical_u64() {
+        let __v_5: G = __r_arr[0];
+        let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_5.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_4]; 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_666] = { let __args: [G; IN_666] = [__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)? } };
     break '__mc_0 [];
   },
   _ => {
@@ -56549,16 +55525,13 @@ fn aiur_fn_667(
   },
 }
  };
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = (__v_2 + __v_7);
-        let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_5, __v_1, __v_8]; 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_6: G = G::from_u64(1);
+        let __v_7: G = (__v_2 + __v_6);
+        let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_4, __v_1, __v_7]; 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 __ret: [G; OUT_667] = [];
         record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
@@ -56577,72 +55550,68 @@ fn aiur_fn_668(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    let __v_8: G = __loaded[4];
-    let __v_9: G = __loaded[5];
-    let __v_10: G = __loaded[6];
-    let __v_11: G = __loaded[7];
-    let __v_12: G = __loaded[8];
-    let __v_13: G = __loaded[9];
-    let __v_14: G = __loaded[10];
-    let __v_15: G = __loaded[11];
-    let __v_16: G = __loaded[12];
-    let __v_17: G = __loaded[13];
-    let __v_18: G = __loaded[14];
-    let __v_19: G = __loaded[15];
-    let __v_20: G = __loaded[16];
-    let __v_21: G = __loaded[17];
-    let __v_22: G = __loaded[18];
-    let __v_23: G = __loaded[19];
-    let __v_24: G = __loaded[20];
-    let __v_25: G = __loaded[21];
-    let __v_26: G = __loaded[22];
-    let __v_27: G = __loaded[23];
-    let __v_28: G = __loaded[24];
-    let __v_29: G = __loaded[25];
-    let __v_30: G = __loaded[26];
-    let __v_31: G = __loaded[27];
-    let __v_32: G = __loaded[28];
-    let __v_33: G = __loaded[29];
-    let __v_34: G = __loaded[30];
-    let __v_35: G = __loaded[31];
-    let __v_36: G = __loaded[32];
-    let __v_37: G = __loaded[33];
-    let __v_38: G = __loaded[34];
-    let __v_39: G = __loaded[35];
-    let __v_40: G = __loaded[36];
-    let __v_41: G = __loaded[37];
-    let __v_42: G = __loaded[38];
-    let __v_43: G = __loaded[39];
-    let __v_44: G = __loaded[40];
-    let __v_45: G = __loaded[41];
-    let __v_46: G = __loaded[42];
-    let __v_47: G = __loaded[43];
-    let __v_48: G = __loaded[44];
-    let __v_49: G = __loaded[45];
-    let __v_50: G = __loaded[46];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
+    match __v_2.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_668] = [];
         record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_51: G = G::from_u64(1);
-        let __v_52: G = (__v_3 + __v_51);
-        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_0, __v_1, __v_50, __v_52]; 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 __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        let __v_8: G = __loaded[4];
+        let __v_9: G = __loaded[5];
+        let __v_10: G = __loaded[6];
+        let __v_11: G = __loaded[7];
+        let __v_12: G = __loaded[8];
+        let __v_13: G = __loaded[9];
+        let __v_14: G = __loaded[10];
+        let __v_15: G = __loaded[11];
+        let __v_16: G = __loaded[12];
+        let __v_17: G = __loaded[13];
+        let __v_18: G = __loaded[14];
+        let __v_19: G = __loaded[15];
+        let __v_20: G = __loaded[16];
+        let __v_21: G = __loaded[17];
+        let __v_22: G = __loaded[18];
+        let __v_23: G = __loaded[19];
+        let __v_24: G = __loaded[20];
+        let __v_25: G = __loaded[21];
+        let __v_26: G = __loaded[22];
+        let __v_27: G = __loaded[23];
+        let __v_28: G = __loaded[24];
+        let __v_29: G = __loaded[25];
+        let __v_30: G = __loaded[26];
+        let __v_31: G = __loaded[27];
+        let __v_32: G = __loaded[28];
+        let __v_33: G = __loaded[29];
+        let __v_34: G = __loaded[30];
+        let __v_35: G = __loaded[31];
+        let __v_36: G = __loaded[32];
+        let __v_37: G = __loaded[33];
+        let __v_38: G = __loaded[34];
+        let __v_39: G = __loaded[35];
+        let __v_40: G = __loaded[36];
+        let __v_41: G = __loaded[37];
+        let __v_42: G = __loaded[38];
+        let __v_43: G = __loaded[39];
+        let __v_44: G = __loaded[40];
+        let __v_45: G = __loaded[41];
+        let __v_46: G = __loaded[42];
+        let __v_47: G = __loaded[43];
+        let __v_48: G = __loaded[44];
+        let __v_49: G = __loaded[45];
+        let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_1, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_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_50: G = G::from_u64(1);
+        let __v_51: G = (__v_3 + __v_50);
+        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_0, __v_1, __v_49, __v_51]; 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 __ret: [G; OUT_668] = [];
         record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
     }
   })
 }
@@ -56709,7 +55678,7 @@ fn aiur_fn_669(
     let __v_48: G = __r_arr[0];
     let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_48]; 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_49: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_50: G = __loaded[0];
     let __v_51: G = __loaded[1];
     let __v_52: G = __loaded[2];
@@ -56740,17 +55709,14 @@ fn aiur_fn_670(
 ) -> Result<[G; OUT_670], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(1);
-    let __v_2: G = G::from_u64(1);
-    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __v_5: G = G::from_u64(0);
-    let __v_6: G = G::from_u64(0);
-    let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_670] = [__v_8];
+    let __v_1: G = G::from_u64(0);
+    let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __v_3: G = G::from_u64(0);
+    let __v_4: G = { let __values: [G; 2] = [__v_3, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_4]; 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_5: G = __r_arr[0];
+    let __ret: [G; OUT_670] = [__v_5];
     record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -56768,19 +55734,16 @@ fn aiur_fn_671(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = G::from_u64(1);
-    let __v_3: G = G::from_u64(1);
-    let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = G::from_u64(0);
-    let __v_8: G = G::from_u64(1);
-    let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __ret: [G; OUT_671] = [__v_10];
+    let __v_2: G = G::from_u64(0);
+    let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = G::from_u64(1);
+    let __v_6: G = { let __values: [G; 2] = [__v_5, __v_4]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __ret: [G; OUT_671] = [__v_7];
     record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -56808,11 +55771,8 @@ fn aiur_fn_672(
         let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_3]; 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_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_672] = [__v_5, __v_10, __v_4];
+        let __v_7: G = { let __values: [G; 2] = [__v_3, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_672] = [__v_5, __v_7, __v_4];
         record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -56849,11 +55809,9 @@ fn aiur_fn_672(
         let __v_32: G = G::from_u64(0);
         let __v_33: G = G::from_u64(0);
         let __v_34: G = G::from_u64(0);
-        let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_36: G = G::from_u64(1);
-        let __v_37: G = G::from_u64(1);
-        let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_672] = [__v_35, __v_38, __v_2];
+        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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_36: G = G::from_u64(0);
+        let __ret: [G; OUT_672] = [__v_35, __v_36, __v_2];
         record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -56868,7 +55826,7 @@ fn aiur_fn_672(
         let __v_8: G = __r_arr[2];
         let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_3, __v_6]; 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_4, __v_7]; 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_10: G = __r_arr[0];
         let __ret: [G; OUT_672] = [__v_9, __v_10, __v_8];
         record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -56892,7 +55850,7 @@ fn aiur_fn_673(
 ) -> Result<[G; OUT_673], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -56947,7 +55905,7 @@ fn aiur_fn_673(
     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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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];
@@ -56988,20 +55946,9 @@ fn aiur_fn_673(
     if (__v_39 != __v_84) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_84.as_canonical_u64(), msg: Some("assumption tree: wrong tag4 variant".to_string()) });
     }
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_85: G = __loaded[0];
-    let __v_86: G = __loaded[1];
-    let __v_87: G = __loaded[2];
-    let __v_88: G = G::from_u64(1);
-    let __v_89: G = G::from_u64(1);
-    if (__v_85 != __v_88) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: Some("assumption tree: trailing bytes after tree body".to_string()) });
-    }
-    if (__v_86 != __v_89) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_89.as_canonical_u64(), msg: Some("assumption tree: trailing bytes after tree body".to_string()) });
-    }
-    if (__v_87 != __v_89) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_89.as_canonical_u64(), msg: Some("assumption tree: trailing bytes after tree body".to_string()) });
+    let __v_85: G = G::from_u64(0);
+    if (__v_50 != __v_85) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_85.as_canonical_u64(), msg: Some("assumption tree: trailing bytes after tree body".to_string()) });
     }
     if (__v_51 != __v_1) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
@@ -57105,9 +56052,9 @@ fn aiur_fn_673(
   })
 }
 
-const INPUT_SIZE_674: usize = 7;
-const IN_674: usize = 7;
-const OUT_674: usize = 6;
+const INPUT_SIZE_674: usize = 6;
+const IN_674: usize = 6;
+const OUT_674: usize = 5;
 fn aiur_fn_674(
   inp: [G; IN_674],
   record: &mut QueryRecord,
@@ -57121,46 +56068,39 @@ fn aiur_fn_674(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_7: G = __loaded[0];
-    let __v_8: G = __loaded[1];
-    let __v_9: G = __loaded[2];
-    match __v_7.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_674] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_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_674] = { let __args: [G; IN_674] = [__v_9, __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_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_674] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
+        let __ret: [G; OUT_674] = [__v_1, __v_2, __v_3, __v_4, __v_5];
         record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = G::from_u64(1);
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_6, __v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; 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_9: G = __r_arr[0];
+        let __v_10: G = __r_arr[1];
+        let __v_11: G = __r_arr[2];
+        let __v_12: G = __r_arr[3];
+        let __v_13: G = __r_arr[4];
+        let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_7, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_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 __ret: [G; OUT_674] = [__v_14, __v_15, __v_16, __v_17, __v_18];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_675: usize = 7;
-const IN_675: usize = 7;
+const INPUT_SIZE_675: usize = 6;
+const IN_675: usize = 6;
 const OUT_675: usize = 1;
 fn aiur_fn_675(
   inp: [G; IN_675],
@@ -57175,18 +56115,17 @@ fn aiur_fn_675(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = G::from_u64(0);
-    let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__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[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_675] = [__v_8];
+    let __v_6: G = G::from_u64(0);
+    let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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_7: G = __r_arr[0];
+    let __ret: [G; OUT_675] = [__v_7];
     record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_676: usize = 14;
-const IN_676: usize = 14;
+const INPUT_SIZE_676: usize = 12;
+const IN_676: usize = 12;
 const OUT_676: usize = 0;
 fn aiur_fn_676(
   inp: [G; IN_676],
@@ -57207,24 +56146,22 @@ fn aiur_fn_676(
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } };
-    let __v_14: G = __r_arr[0];
-    match __v_14.as_canonical_u64() {
+    let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } };
+    let __v_12: G = __r_arr[0];
+    match __v_12.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_676] = [];
         record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_13.as_canonical_u64() {
+        let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_11.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __v_16: G = G::from_u64(1);
-    if (__v_15 != __v_16) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("CheckEnv: walk reached a constant outside the owned set".to_string()) });
+    let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __v_14: G = G::from_u64(1);
+    if (__v_13 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("CheckEnv: walk reached a constant outside the owned set".to_string()) });
     }
     break '__mc_0 [];
   },
@@ -57234,94 +56171,94 @@ fn aiur_fn_676(
 }
  };
         let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0]; 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 __v_16: G = __r_arr[1];
-        let __v_17: G = __r_arr[2];
-        let __v_18: G = __r_arr[3];
-        let __v_19: G = __r_arr[4];
-        let __v_20: G = __r_arr[5];
-        let __v_21: G = __r_arr[6];
-        let __v_22: G = __r_arr[7];
-        let __v_23: G = __r_arr[8];
-        let __v_24: G = __r_arr[9];
-        let __v_25: G = __r_arr[10];
-        let __v_26: G = __r_arr[11];
-        let __v_27: G = __r_arr[12];
-        let __v_28: G = __r_arr[13];
-        let __v_29: G = __r_arr[14];
-        let __v_30: G = __r_arr[15];
-        let __v_31: G = __r_arr[16];
-        let __v_32: G = __r_arr[17];
-        let __v_33: G = __r_arr[18];
-        let __v_34: G = __r_arr[19];
-        let __v_35: G = __r_arr[20];
-        let __v_36: G = __r_arr[21];
-        let __v_37: G = __r_arr[22];
-        let __v_38: G = __r_arr[23];
-        let __v_39: G = __r_arr[24];
-        let __v_40: G = __r_arr[25];
-        let __v_41: G = __r_arr[26];
-        let __v_42: G = __r_arr[27];
-        let __v_43: G = __r_arr[28];
-        let __v_44: G = __r_arr[29];
-        let __v_45: G = __r_arr[30];
-        let __v_46: G = __r_arr[31];
-        let __v_47: G = __r_arr[32];
-        let __v_48: G = __r_arr[33];
-        let __v_49: G = __r_arr[34];
-        let __v_50: G = __r_arr[35];
-        let __v_51: G = __r_arr[36];
-        let __v_52: G = __r_arr[37];
-        let __v_53: G = __r_arr[38];
-        let __v_54: G = __r_arr[39];
-        let __v_55: G = __r_arr[40];
-        let __v_56: G = __r_arr[41];
-        let __v_57: G = __r_arr[42];
-        let __v_58: G = __r_arr[43];
-        let __v_59: G = __r_arr[44];
-        let __v_60: G = __r_arr[45];
-        let __v_61: G = __r_arr[46];
-        let __v_62: G = __r_arr[47];
-        match __v_15.as_canonical_u64() {
+        let __v_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __v_15: G = __r_arr[2];
+        let __v_16: G = __r_arr[3];
+        let __v_17: G = __r_arr[4];
+        let __v_18: G = __r_arr[5];
+        let __v_19: G = __r_arr[6];
+        let __v_20: G = __r_arr[7];
+        let __v_21: G = __r_arr[8];
+        let __v_22: G = __r_arr[9];
+        let __v_23: G = __r_arr[10];
+        let __v_24: G = __r_arr[11];
+        let __v_25: G = __r_arr[12];
+        let __v_26: G = __r_arr[13];
+        let __v_27: G = __r_arr[14];
+        let __v_28: G = __r_arr[15];
+        let __v_29: G = __r_arr[16];
+        let __v_30: G = __r_arr[17];
+        let __v_31: G = __r_arr[18];
+        let __v_32: G = __r_arr[19];
+        let __v_33: G = __r_arr[20];
+        let __v_34: G = __r_arr[21];
+        let __v_35: G = __r_arr[22];
+        let __v_36: G = __r_arr[23];
+        let __v_37: G = __r_arr[24];
+        let __v_38: G = __r_arr[25];
+        let __v_39: G = __r_arr[26];
+        let __v_40: G = __r_arr[27];
+        let __v_41: G = __r_arr[28];
+        let __v_42: G = __r_arr[29];
+        let __v_43: G = __r_arr[30];
+        let __v_44: G = __r_arr[31];
+        let __v_45: G = __r_arr[32];
+        let __v_46: G = __r_arr[33];
+        let __v_47: G = __r_arr[34];
+        let __v_48: G = __r_arr[35];
+        let __v_49: G = __r_arr[36];
+        let __v_50: G = __r_arr[37];
+        let __v_51: G = __r_arr[38];
+        let __v_52: G = __r_arr[39];
+        let __v_53: G = __r_arr[40];
+        let __v_54: G = __r_arr[41];
+        let __v_55: G = __r_arr[42];
+        let __v_56: G = __r_arr[43];
+        let __v_57: G = __r_arr[44];
+        let __v_58: G = __r_arr[45];
+        let __v_59: G = __r_arr[46];
+        let __v_60: G = __r_arr[47];
+        match __v_13.as_canonical_u64() {
           _ => {
-            let __mc_out___mc_1: [G; 0] = '__mc_1: { match __v_15.as_canonical_u64() {
+            let __mc_out___mc_1: [G; 0] = '__mc_1: { match __v_13.as_canonical_u64() {
   8u64 => {
-    let __v_63: G = G::from_u64(0);
-    let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
+    let __v_61: G = G::from_u64(0);
+    let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_0, __v_14, __v_14, __v_61]; 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)? } };
     break '__mc_1 [];
   },
   7u64 => {
-    match __v_16.as_canonical_u64() {
+    match __v_14.as_canonical_u64() {
       _ => {
         let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_0]; 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_676] = { let __args: [G; IN_676] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_676] = { let __args: [G; IN_676] = [__v_22, __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[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)? } };
         break '__mc_1 [];
       },
     }
   },
   6u64 => {
-    match __v_16.as_canonical_u64() {
+    match __v_14.as_canonical_u64() {
       _ => {
         let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_0]; 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_676] = { let __args: [G; IN_676] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_676] = { let __args: [G; IN_676] = [__v_22, __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[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)? } };
         break '__mc_1 [];
       },
     }
   },
   4u64 => {
-    match __v_16.as_canonical_u64() {
+    match __v_14.as_canonical_u64() {
       _ => {
         let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_0]; 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_676] = { let __args: [G; IN_676] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_676] = { let __args: [G; IN_676] = [__v_30, __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[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)? } };
         break '__mc_1 [];
       },
     }
   },
   5u64 => {
-    match __v_16.as_canonical_u64() {
+    match __v_14.as_canonical_u64() {
       _ => {
         let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_0]; 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_676] = { let __args: [G; IN_676] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_676] = { let __args: [G; IN_676] = [__v_22, __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[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)? } };
         break '__mc_1 [];
       },
     }
@@ -57332,10 +56269,10 @@ fn aiur_fn_676(
   },
 }
  };
-            let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_63: G = __r_arr[0];
-            let __v_64: G = G::from_u64(0);
-            let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_664] = { let __args: [G; IN_664] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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]; 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_61: G = __r_arr[0];
+            let __v_62: G = G::from_u64(0);
+            let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_59, __v_61, __v_62, __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[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 __ret: [G; OUT_676] = [];
             record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -57346,8 +56283,8 @@ fn aiur_fn_676(
   })
 }
 
-const INPUT_SIZE_677: usize = 16;
-const IN_677: usize = 16;
+const INPUT_SIZE_677: usize = 14;
+const IN_677: usize = 14;
 const OUT_677: usize = 0;
 fn aiur_fn_677(
   inp: [G; IN_677],
@@ -57370,24 +56307,21 @@ fn aiur_fn_677(
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
     let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_16: G = __loaded[0];
-    let __v_17: G = __loaded[1];
-    let __v_18: G = __loaded[2];
-    match __v_16.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_677] = [];
         record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_14: G = __loaded[0];
+        let __v_15: G = __loaded[1];
         let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_19.as_canonical_u64() {
+        let __v_16: G = __r_arr[0];
+        let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_16.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_676] = { let __args: [G; IN_676] = [__v_14, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[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)? } };
     break '__mc_0 [];
   },
   _ => {
@@ -57395,22 +56329,19 @@ fn aiur_fn_677(
   },
 }
  };
-        let __v_20: G = G::from_u64(1);
-        let __v_21: G = (__v_2 + __v_20);
-        let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_17: G = G::from_u64(1);
+        let __v_18: G = (__v_2 + __v_17);
+        let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_15, __v_1, __v_18, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __ret: [G; OUT_677] = [];
         record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_678: usize = 13;
-const IN_678: usize = 13;
+const INPUT_SIZE_678: usize = 11;
+const IN_678: usize = 11;
 const OUT_678: usize = 0;
 fn aiur_fn_678(
   inp: [G; IN_678],
@@ -57430,35 +56361,29 @@ fn aiur_fn_678(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_13: G = __loaded[0];
-    let __v_14: G = __loaded[1];
-    let __v_15: G = __loaded[2];
-    match __v_13.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_678] = [];
         record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_16: G = G::from_u64(1);
-        let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_678] = { let __args: [G; IN_678] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[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 __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_11: G = __loaded[0];
+        let __v_12: G = __loaded[1];
+        let __v_13: G = G::from_u64(1);
+        let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; 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_678] = { let __args: [G; IN_678] = [__v_12, __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[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 __ret: [G; OUT_678] = [];
         record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_679: usize = 3;
-const IN_679: usize = 3;
+const INPUT_SIZE_679: usize = 2;
+const IN_679: usize = 2;
 const OUT_679: usize = 0;
 fn aiur_fn_679(
   inp: [G; IN_679],
@@ -57469,46 +56394,36 @@ fn aiur_fn_679(
   stacker::maybe_grow(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_673] = { let __args: [G; IN_673] = [__v_0]; 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_3: G = __r_arr[0];
+    let __v_2: G = __r_arr[0];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() {
-  1u64 => {
-    let __v_4: G = G::from_u64(1);
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    break '__mc_0 [__v_6];
-  },
   0u64 => {
-    let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } else { aiur_fn_673(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    break '__mc_0 [__v_4];
+    let __v_3: G = G::from_u64(0);
+    break '__mc_0 [__v_3];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+    let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_1]; 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_3: G = __r_arr[0];
+    break '__mc_0 [__v_3];
   },
 }
  };
-    let __v_4: G = __mc_out___mc_0[0];
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = G::from_u64(1);
-    let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __v_8: G = __r_arr[1];
-    let __v_9: G = __r_arr[2];
-    let __v_10: G = __r_arr[3];
-    let __v_11: G = __r_arr[4];
-    let __v_12: G = __r_arr[5];
-    let __v_13: G = G::from_u64(1);
-    let __v_14: G = G::from_u64(1);
-    let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; 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_15: G = __r_arr[0];
-    let __v_16: G = __r_arr[1];
-    let __v_17: G = __r_arr[2];
-    let __v_18: G = __r_arr[3];
-    let __v_19: G = __r_arr[4];
-    let __v_20: G = __r_arr[5];
-    let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_3: G = __mc_out___mc_0[0];
+    let __v_4: G = G::from_u64(0);
+    let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_2, __v_4, __v_4, __v_4, __v_4, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __v_7: G = __r_arr[2];
+    let __v_8: G = __r_arr[3];
+    let __v_9: G = __r_arr[4];
+    let __v_10: G = G::from_u64(0);
+    let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_3, __v_10, __v_10, __v_10, __v_10, __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_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 __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_2, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15]; 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 __ret: [G; OUT_679] = [];
     record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
@@ -57517,7 +56432,7 @@ fn aiur_fn_679(
 
 const INPUT_SIZE_680: usize = 1;
 const IN_680: usize = 1;
-const OUT_680: usize = 3;
+const OUT_680: usize = 2;
 fn aiur_fn_680(
   inp: [G; IN_680],
   record: &mut QueryRecord,
@@ -57531,9 +56446,8 @@ fn aiur_fn_680(
     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_680] = [__v_3, __v_4, __v_2];
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_680] = [__v_3, __v_2];
         record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -57541,8 +56455,7 @@ fn aiur_fn_680(
         let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_680] = [__v_5, __v_3, __v_4];
+        let __ret: [G; OUT_680] = [__v_3, __v_4];
         record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -57595,7 +56508,7 @@ fn aiur_fn_681(
 
 const INPUT_SIZE_682: usize = 2;
 const IN_682: usize = 2;
-const OUT_682: usize = 3;
+const OUT_682: usize = 2;
 fn aiur_fn_682(
   inp: [G; IN_682],
   record: &mut QueryRecord,
@@ -57607,9 +56520,8 @@ fn aiur_fn_682(
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_682] = [__v_2, __v_3, __v_1];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_682] = [__v_2, __v_1];
         record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -57617,8 +56529,7 @@ fn aiur_fn_682(
         let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_682] = [__v_4, __v_2, __v_3];
+        let __ret: [G; OUT_682] = [__v_2, __v_3];
         record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -57799,10 +56710,8 @@ fn aiur_fn_686(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 19] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_686] = [__v_12, __v_0];
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_686] = [__v_10, __v_0];
         record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -57838,9 +56747,8 @@ fn aiur_fn_686(
         let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__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[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 __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_686] = [__v_39, __v_37];
+        let __v_38: G = { let __values: [G; 18] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_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(&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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_686] = [__v_38, __v_37];
         record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -57893,7 +56801,7 @@ fn aiur_fn_687(
 
 const INPUT_SIZE_688: usize = 1;
 const IN_688: usize = 1;
-const OUT_688: usize = 41;
+const OUT_688: usize = 40;
 fn aiur_fn_688(
   inp: [G; IN_688],
   record: &mut QueryRecord,
@@ -57972,8 +56880,7 @@ fn aiur_fn_688(
     let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_15, __v_60]; 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_61: G = __r_arr[0];
     let __v_62: G = __r_arr[1];
-    let __v_63: G = __r_arr[2];
-    let __ret: [G; OUT_688] = [__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];
+    let __ret: [G; OUT_688] = [__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];
     record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -57981,7 +56888,7 @@ fn aiur_fn_688(
 
 const INPUT_SIZE_689: usize = 1;
 const IN_689: usize = 1;
-const OUT_689: usize = 49;
+const OUT_689: usize = 48;
 fn aiur_fn_689(
   inp: [G; IN_689],
   record: &mut QueryRecord,
@@ -58041,8 +56948,7 @@ fn aiur_fn_689(
     let __v_47: G = __r_arr[37];
     let __v_48: G = __r_arr[38];
     let __v_49: G = __r_arr[39];
-    let __v_50: G = __r_arr[40];
-    let __ret: [G; OUT_689] = [__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];
+    let __ret: [G; OUT_689] = [__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];
     record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -58071,10 +56977,8 @@ fn aiur_fn_690(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 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_690] = [__v_12, __v_0];
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_690] = [__v_10, __v_0];
         record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58128,22 +57032,20 @@ fn aiur_fn_690(
         let __v_55: G = __r_arr[45];
         let __v_56: G = __r_arr[46];
         let __v_57: G = __r_arr[47];
-        let __v_58: G = __r_arr[48];
         let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
-        let __v_59: G = __r_arr[0];
-        let __v_60: G = __r_arr[1];
-        let __v_61: G = __r_arr[2];
-        let __v_62: G = __r_arr[3];
-        let __v_63: G = __r_arr[4];
-        let __v_64: G = __r_arr[5];
-        let __v_65: G = __r_arr[6];
-        let __v_66: G = __r_arr[7];
-        let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__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[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_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_690] = [__v_70, __v_68];
+        let __v_58: G = __r_arr[0];
+        let __v_59: G = __r_arr[1];
+        let __v_60: G = __r_arr[2];
+        let __v_61: G = __r_arr[3];
+        let __v_62: G = __r_arr[4];
+        let __v_63: G = __r_arr[5];
+        let __v_64: G = __r_arr[6];
+        let __v_65: G = __r_arr[7];
+        let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__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[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_66: G = __r_arr[0];
+        let __v_67: G = __r_arr[1];
+        let __v_68: G = { let __values: [G; 48] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_66]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_690] = [__v_68, __v_67];
         record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58196,7 +57098,7 @@ fn aiur_fn_691(
 
 const INPUT_SIZE_692: usize = 1;
 const IN_692: usize = 1;
-const OUT_692: usize = 55;
+const OUT_692: usize = 54;
 fn aiur_fn_692(
   inp: [G; IN_692],
   record: &mut QueryRecord,
@@ -58260,14 +57162,12 @@ fn aiur_fn_692(
         let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_15, __v_43]; 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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
-        let __v_46: G = __r_arr[2];
-        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_16, __v_46]; 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_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_692] = [__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];
+        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_16, __v_45]; 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_46: G = __r_arr[0];
+        let __v_47: G = __r_arr[1];
+        let __v_48: G = G::from_u64(0);
+        let __v_49: G = G::from_u64(0);
+        let __ret: [G; OUT_692] = [__v_48, __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_46, __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, __v_49, __v_49, __v_49, __v_49, __v_47];
         record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58312,14 +57212,13 @@ fn aiur_fn_692(
         let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_16, __v_60]; 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_61: G = __r_arr[0];
         let __v_62: G = __r_arr[1];
-        let __v_63: G = __r_arr[2];
-        let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_17, __v_63]; 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_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_692] = [__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];
+        let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_17, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+        let __v_63: G = __r_arr[0];
+        let __v_64: G = __r_arr[1];
+        let __v_65: G = __r_arr[2];
+        let __v_66: G = G::from_u64(1);
+        let __v_67: G = G::from_u64(0);
+        let __ret: [G; OUT_692] = [__v_66, __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_63, __v_64, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_65];
         record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58390,13 +57289,12 @@ fn aiur_fn_692(
         let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_19, __v_83]; 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_84: G = __r_arr[0];
         let __v_85: G = __r_arr[1];
-        let __v_86: G = __r_arr[2];
-        let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } };
-        let __v_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_692] = [__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];
+        let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_20, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } };
+        let __v_86: G = __r_arr[0];
+        let __v_87: G = __r_arr[1];
+        let __v_88: G = __r_arr[2];
+        let __v_89: G = G::from_u64(2);
+        let __ret: [G; OUT_692] = [__v_89, __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_86, __v_87, __v_88];
         record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58409,7 +57307,7 @@ fn aiur_fn_692(
 
 const INPUT_SIZE_693: usize = 1;
 const IN_693: usize = 1;
-const OUT_693: usize = 63;
+const OUT_693: usize = 62;
 fn aiur_fn_693(
   inp: [G; IN_693],
   record: &mut QueryRecord,
@@ -58483,8 +57381,7 @@ fn aiur_fn_693(
     let __v_61: G = __r_arr[51];
     let __v_62: G = __r_arr[52];
     let __v_63: G = __r_arr[53];
-    let __v_64: G = __r_arr[54];
-    let __ret: [G; OUT_693] = [__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];
+    let __ret: [G; OUT_693] = [__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];
     record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -58513,10 +57410,8 @@ fn aiur_fn_694(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 64] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_694] = [__v_12, __v_0];
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_694] = [__v_10, __v_0];
         record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58584,22 +57479,20 @@ fn aiur_fn_694(
         let __v_69: G = __r_arr[59];
         let __v_70: G = __r_arr[60];
         let __v_71: G = __r_arr[61];
-        let __v_72: G = __r_arr[62];
         let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
-        let __v_73: G = __r_arr[0];
-        let __v_74: G = __r_arr[1];
-        let __v_75: G = __r_arr[2];
-        let __v_76: G = __r_arr[3];
-        let __v_77: G = __r_arr[4];
-        let __v_78: G = __r_arr[5];
-        let __v_79: G = __r_arr[6];
-        let __v_80: G = __r_arr[7];
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__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[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_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_694] = [__v_84, __v_82];
+        let __v_72: G = __r_arr[0];
+        let __v_73: G = __r_arr[1];
+        let __v_74: G = __r_arr[2];
+        let __v_75: G = __r_arr[3];
+        let __v_76: G = __r_arr[4];
+        let __v_77: G = __r_arr[5];
+        let __v_78: G = __r_arr[6];
+        let __v_79: G = __r_arr[7];
+        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_71, __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[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_80: G = __r_arr[0];
+        let __v_81: G = __r_arr[1];
+        let __v_82: G = { let __values: [G; 62] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_80]; let __mq = record.memory_queries.get_mut(&62).ok_or(ExecError::InvalidMemorySize(62))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_694] = [__v_82, __v_81];
         record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58609,7 +57502,7 @@ fn aiur_fn_694(
 
 const INPUT_SIZE_695: usize = 1;
 const IN_695: usize = 1;
-const OUT_695: usize = 55;
+const OUT_695: usize = 54;
 fn aiur_fn_695(
   inp: [G; IN_695],
   record: &mut QueryRecord,
@@ -58673,14 +57566,12 @@ fn aiur_fn_695(
         let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_15, __v_43]; 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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
-        let __v_46: G = __r_arr[2];
-        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_16, __v_46]; 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_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_695] = [__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];
+        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_16, __v_45]; 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_46: G = __r_arr[0];
+        let __v_47: G = __r_arr[1];
+        let __v_48: G = G::from_u64(0);
+        let __v_49: G = G::from_u64(0);
+        let __ret: [G; OUT_695] = [__v_48, __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_46, __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, __v_49, __v_49, __v_49, __v_49, __v_47];
         record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58751,13 +57642,12 @@ fn aiur_fn_695(
         let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_19, __v_83]; 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_84: G = __r_arr[0];
         let __v_85: G = __r_arr[1];
-        let __v_86: G = __r_arr[2];
-        let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } };
-        let __v_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_695] = [__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];
+        let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_20, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } };
+        let __v_86: G = __r_arr[0];
+        let __v_87: G = __r_arr[1];
+        let __v_88: G = __r_arr[2];
+        let __v_89: G = G::from_u64(1);
+        let __ret: [G; OUT_695] = [__v_89, __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_86, __v_87, __v_88];
         record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58780,10 +57670,9 @@ fn aiur_fn_695(
         let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_14, __v_40]; 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_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_695] = [__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];
+        let __v_43: G = G::from_u64(2);
+        let __v_44: G = G::from_u64(0);
+        let __ret: [G; OUT_695] = [__v_43, __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_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_42];
         record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58806,10 +57695,9 @@ fn aiur_fn_695(
         let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_14, __v_40]; 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_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_695] = [__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];
+        let __v_43: G = G::from_u64(3);
+        let __v_44: G = G::from_u64(0);
+        let __ret: [G; OUT_695] = [__v_43, __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_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_42];
         record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58839,10 +57727,9 @@ fn aiur_fn_695(
         let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_14, __v_47]; 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_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_695] = [__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];
+        let __v_50: G = G::from_u64(4);
+        let __v_51: G = G::from_u64(0);
+        let __ret: [G; OUT_695] = [__v_50, __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_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_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[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58861,10 +57748,9 @@ fn aiur_fn_695(
         let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_13, __v_37]; 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_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_695] = [__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];
+        let __v_40: G = G::from_u64(5);
+        let __v_41: G = G::from_u64(0);
+        let __ret: [G; OUT_695] = [__v_40, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_39];
         record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58883,10 +57769,9 @@ fn aiur_fn_695(
         let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_13, __v_37]; 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_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_695] = [__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];
+        let __v_40: G = G::from_u64(6);
+        let __v_41: G = G::from_u64(0);
+        let __ret: [G; OUT_695] = [__v_40, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_39];
         record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58905,20 +57790,17 @@ fn aiur_fn_695(
         let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_13, __v_37]; 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_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_695] = [__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];
+        let __v_40: G = G::from_u64(7);
+        let __v_41: G = G::from_u64(0);
+        let __ret: [G; OUT_695] = [__v_40, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_39];
         record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_12.as_canonical_u64() {
   0u64 => {
-    let __v_28: G = G::from_u64(1);
-    let __v_29: G = G::from_u64(1);
-    let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    break '__mc_0 [__v_30, __v_11];
+    let __v_28: G = G::from_u64(0);
+    break '__mc_0 [__v_28, __v_11];
   },
   1u64 => {
     let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
@@ -58945,7 +57827,7 @@ fn aiur_fn_695(
         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_695] = [__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];
+        let __ret: [G; OUT_695] = [__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_29];
         record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -58967,7 +57849,7 @@ fn aiur_fn_696(
 ) -> Result<[G; OUT_696], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+    let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -58986,14 +57868,12 @@ fn aiur_fn_696(
     let __v_16: G = __loaded[15];
     let __v_17: G = __loaded[16];
     let __v_18: G = __loaded[17];
-    let __v_19: G = G::from_u64(1);
-    let __v_20: G = G::from_u64(1);
-    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
-    let __v_22: G = __r_arr[0];
-    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
-    let __v_23: G = __r_arr[0];
-    let __ret: [G; OUT_696] = [__v_23];
+    let __v_19: G = G::from_u64(0);
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_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[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_20: G = __r_arr[0];
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
+    let __v_21: G = __r_arr[0];
+    let __ret: [G; OUT_696] = [__v_21];
     record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -59253,8 +58133,8 @@ fn aiur_fn_702(
   })
 }
 
-const INPUT_SIZE_703: usize = 3;
-const IN_703: usize = 3;
+const INPUT_SIZE_703: usize = 2;
+const IN_703: usize = 2;
 const OUT_703: usize = 0;
 fn aiur_fn_703(
   inp: [G; IN_703],
@@ -59265,80 +58145,82 @@ fn aiur_fn_703(
   stacker::maybe_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 => {
+      0u64 => {
         let __ret: [G; OUT_703] = [];
         record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_3: G = __loaded[0];
-        let __v_4: G = __loaded[1];
-        let __v_5: G = __loaded[2];
-        let __v_6: G = __loaded[3];
-        let __v_7: G = __loaded[4];
-        let __v_8: G = __loaded[5];
-        let __v_9: G = __loaded[6];
-        let __v_10: G = __loaded[7];
-        let __v_11: G = __loaded[8];
-        let __v_12: G = __loaded[9];
-        let __v_13: G = __loaded[10];
-        let __v_14: G = __loaded[11];
-        let __v_15: G = __loaded[12];
-        let __v_16: G = __loaded[13];
-        let __v_17: G = __loaded[14];
-        let __v_18: G = __loaded[15];
-        let __v_19: G = __loaded[16];
-        let __v_20: G = __loaded[17];
-        let __v_21: G = __loaded[18];
-        let __v_22: G = __loaded[19];
-        let __v_23: G = __loaded[20];
-        let __v_24: G = __loaded[21];
-        let __v_25: G = __loaded[22];
-        let __v_26: G = __loaded[23];
-        let __v_27: G = __loaded[24];
-        let __v_28: G = __loaded[25];
-        let __v_29: G = __loaded[26];
-        let __v_30: G = __loaded[27];
-        let __v_31: G = __loaded[28];
-        let __v_32: G = __loaded[29];
-        let __v_33: G = __loaded[30];
-        let __v_34: G = __loaded[31];
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_35: G = __loaded[0];
-        let __v_36: G = __loaded[1];
-        let __v_37: G = __loaded[2];
-        let __v_38: G = __loaded[3];
-        let __v_39: G = __loaded[4];
-        let __v_40: G = __loaded[5];
-        let __v_41: G = __loaded[6];
-        let __v_42: G = __loaded[7];
-        let __v_43: G = __loaded[8];
-        let __v_44: G = __loaded[9];
-        let __v_45: G = __loaded[10];
-        let __v_46: G = __loaded[11];
-        let __v_47: G = __loaded[12];
-        let __v_48: G = __loaded[13];
-        let __v_49: G = __loaded[14];
-        let __v_50: G = __loaded[15];
-        let __v_51: G = __loaded[16];
-        let __v_52: G = __loaded[17];
-        let __v_53: G = __loaded[18];
-        let __v_54: G = __loaded[19];
-        let __v_55: G = __loaded[20];
-        let __v_56: G = __loaded[21];
-        let __v_57: G = __loaded[22];
-        let __v_58: G = __loaded[23];
-        let __v_59: G = __loaded[24];
-        let __v_60: G = __loaded[25];
-        let __v_61: G = __loaded[26];
-        let __v_62: G = __loaded[27];
-        let __v_63: G = __loaded[28];
-        let __v_64: G = __loaded[29];
-        let __v_65: G = __loaded[30];
-        let __v_66: G = __loaded[31];
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __v_11: G = __loaded[9];
+        let __v_12: G = __loaded[10];
+        let __v_13: G = __loaded[11];
+        let __v_14: G = __loaded[12];
+        let __v_15: G = __loaded[13];
+        let __v_16: G = __loaded[14];
+        let __v_17: G = __loaded[15];
+        let __v_18: G = __loaded[16];
+        let __v_19: G = __loaded[17];
+        let __v_20: G = __loaded[18];
+        let __v_21: G = __loaded[19];
+        let __v_22: G = __loaded[20];
+        let __v_23: G = __loaded[21];
+        let __v_24: G = __loaded[22];
+        let __v_25: G = __loaded[23];
+        let __v_26: G = __loaded[24];
+        let __v_27: G = __loaded[25];
+        let __v_28: G = __loaded[26];
+        let __v_29: G = __loaded[27];
+        let __v_30: G = __loaded[28];
+        let __v_31: G = __loaded[29];
+        let __v_32: G = __loaded[30];
+        let __v_33: G = __loaded[31];
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_34: G = __loaded[0];
+        let __v_35: G = __loaded[1];
+        let __v_36: G = __loaded[2];
+        let __v_37: G = __loaded[3];
+        let __v_38: G = __loaded[4];
+        let __v_39: G = __loaded[5];
+        let __v_40: G = __loaded[6];
+        let __v_41: G = __loaded[7];
+        let __v_42: G = __loaded[8];
+        let __v_43: G = __loaded[9];
+        let __v_44: G = __loaded[10];
+        let __v_45: G = __loaded[11];
+        let __v_46: G = __loaded[12];
+        let __v_47: G = __loaded[13];
+        let __v_48: G = __loaded[14];
+        let __v_49: G = __loaded[15];
+        let __v_50: G = __loaded[16];
+        let __v_51: G = __loaded[17];
+        let __v_52: G = __loaded[18];
+        let __v_53: G = __loaded[19];
+        let __v_54: G = __loaded[20];
+        let __v_55: G = __loaded[21];
+        let __v_56: G = __loaded[22];
+        let __v_57: G = __loaded[23];
+        let __v_58: G = __loaded[24];
+        let __v_59: G = __loaded[25];
+        let __v_60: G = __loaded[26];
+        let __v_61: G = __loaded[27];
+        let __v_62: G = __loaded[28];
+        let __v_63: G = __loaded[29];
+        let __v_64: G = __loaded[30];
+        let __v_65: G = __loaded[31];
+        if (__v_2 != __v_34) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
         if (__v_3 != __v_35) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
         }
@@ -59432,22 +58314,16 @@ fn aiur_fn_703(
         if (__v_33 != __v_65) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
         }
-        if (__v_34 != __v_66) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
-        }
         let __ret: [G; OUT_703] = [];
         record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_704: usize = 3;
-const IN_704: usize = 3;
+const INPUT_SIZE_704: usize = 2;
+const IN_704: usize = 2;
 const OUT_704: usize = 0;
 fn aiur_fn_704(
   inp: [G; IN_704],
@@ -59458,82 +58334,84 @@ fn aiur_fn_704(
   stacker::maybe_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 => {
+      0u64 => {
         let __ret: [G; OUT_704] = [];
         record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
+      _ => {
         let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_0]; 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_3: G = __r_arr[0];
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_4: G = __loaded[0];
-        let __v_5: G = __loaded[1];
-        let __v_6: G = __loaded[2];
-        let __v_7: G = __loaded[3];
-        let __v_8: G = __loaded[4];
-        let __v_9: G = __loaded[5];
-        let __v_10: G = __loaded[6];
-        let __v_11: G = __loaded[7];
-        let __v_12: G = __loaded[8];
-        let __v_13: G = __loaded[9];
-        let __v_14: G = __loaded[10];
-        let __v_15: G = __loaded[11];
-        let __v_16: G = __loaded[12];
-        let __v_17: G = __loaded[13];
-        let __v_18: G = __loaded[14];
-        let __v_19: G = __loaded[15];
-        let __v_20: G = __loaded[16];
-        let __v_21: G = __loaded[17];
-        let __v_22: G = __loaded[18];
-        let __v_23: G = __loaded[19];
-        let __v_24: G = __loaded[20];
-        let __v_25: G = __loaded[21];
-        let __v_26: G = __loaded[22];
-        let __v_27: G = __loaded[23];
-        let __v_28: G = __loaded[24];
-        let __v_29: G = __loaded[25];
-        let __v_30: G = __loaded[26];
-        let __v_31: G = __loaded[27];
-        let __v_32: G = __loaded[28];
-        let __v_33: G = __loaded[29];
-        let __v_34: G = __loaded[30];
-        let __v_35: G = __loaded[31];
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_36: G = __loaded[0];
-        let __v_37: G = __loaded[1];
-        let __v_38: G = __loaded[2];
-        let __v_39: G = __loaded[3];
-        let __v_40: G = __loaded[4];
-        let __v_41: G = __loaded[5];
-        let __v_42: G = __loaded[6];
-        let __v_43: G = __loaded[7];
-        let __v_44: G = __loaded[8];
-        let __v_45: G = __loaded[9];
-        let __v_46: G = __loaded[10];
-        let __v_47: G = __loaded[11];
-        let __v_48: G = __loaded[12];
-        let __v_49: G = __loaded[13];
-        let __v_50: G = __loaded[14];
-        let __v_51: G = __loaded[15];
-        let __v_52: G = __loaded[16];
-        let __v_53: G = __loaded[17];
-        let __v_54: G = __loaded[18];
-        let __v_55: G = __loaded[19];
-        let __v_56: G = __loaded[20];
-        let __v_57: G = __loaded[21];
-        let __v_58: G = __loaded[22];
-        let __v_59: G = __loaded[23];
-        let __v_60: G = __loaded[24];
-        let __v_61: G = __loaded[25];
-        let __v_62: G = __loaded[26];
-        let __v_63: G = __loaded[27];
-        let __v_64: G = __loaded[28];
-        let __v_65: G = __loaded[29];
-        let __v_66: G = __loaded[30];
-        let __v_67: G = __loaded[31];
+        let __v_2: 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_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        let __v_7: G = __loaded[4];
+        let __v_8: G = __loaded[5];
+        let __v_9: G = __loaded[6];
+        let __v_10: G = __loaded[7];
+        let __v_11: G = __loaded[8];
+        let __v_12: G = __loaded[9];
+        let __v_13: G = __loaded[10];
+        let __v_14: G = __loaded[11];
+        let __v_15: G = __loaded[12];
+        let __v_16: G = __loaded[13];
+        let __v_17: G = __loaded[14];
+        let __v_18: G = __loaded[15];
+        let __v_19: G = __loaded[16];
+        let __v_20: G = __loaded[17];
+        let __v_21: G = __loaded[18];
+        let __v_22: G = __loaded[19];
+        let __v_23: G = __loaded[20];
+        let __v_24: G = __loaded[21];
+        let __v_25: G = __loaded[22];
+        let __v_26: G = __loaded[23];
+        let __v_27: G = __loaded[24];
+        let __v_28: G = __loaded[25];
+        let __v_29: G = __loaded[26];
+        let __v_30: G = __loaded[27];
+        let __v_31: G = __loaded[28];
+        let __v_32: G = __loaded[29];
+        let __v_33: G = __loaded[30];
+        let __v_34: G = __loaded[31];
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_35: G = __loaded[0];
+        let __v_36: G = __loaded[1];
+        let __v_37: G = __loaded[2];
+        let __v_38: G = __loaded[3];
+        let __v_39: G = __loaded[4];
+        let __v_40: G = __loaded[5];
+        let __v_41: G = __loaded[6];
+        let __v_42: G = __loaded[7];
+        let __v_43: G = __loaded[8];
+        let __v_44: G = __loaded[9];
+        let __v_45: G = __loaded[10];
+        let __v_46: G = __loaded[11];
+        let __v_47: G = __loaded[12];
+        let __v_48: G = __loaded[13];
+        let __v_49: G = __loaded[14];
+        let __v_50: G = __loaded[15];
+        let __v_51: G = __loaded[16];
+        let __v_52: G = __loaded[17];
+        let __v_53: G = __loaded[18];
+        let __v_54: G = __loaded[19];
+        let __v_55: G = __loaded[20];
+        let __v_56: G = __loaded[21];
+        let __v_57: G = __loaded[22];
+        let __v_58: G = __loaded[23];
+        let __v_59: G = __loaded[24];
+        let __v_60: G = __loaded[25];
+        let __v_61: G = __loaded[26];
+        let __v_62: G = __loaded[27];
+        let __v_63: G = __loaded[28];
+        let __v_64: G = __loaded[29];
+        let __v_65: G = __loaded[30];
+        let __v_66: G = __loaded[31];
+        if (__v_3 != __v_35) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
         if (__v_4 != __v_36) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
         }
@@ -59627,16 +58505,10 @@ fn aiur_fn_704(
         if (__v_34 != __v_66) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
         }
-        if (__v_35 != __v_67) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
-        }
         let __ret: [G; OUT_704] = [];
         record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -59661,130 +58533,125 @@ fn aiur_fn_705(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __loaded: [G; 19] = { let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 19 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 19] = __args[..19].try_into().unwrap(); __arr };
-    let __v_10: G = __loaded[0];
-    let __v_11: G = __loaded[1];
-    let __v_12: G = __loaded[2];
-    let __v_13: G = __loaded[3];
-    let __v_14: G = __loaded[4];
-    let __v_15: G = __loaded[5];
-    let __v_16: G = __loaded[6];
-    let __v_17: G = __loaded[7];
-    let __v_18: G = __loaded[8];
-    let __v_19: G = __loaded[9];
-    let __v_20: G = __loaded[10];
-    let __v_21: G = __loaded[11];
-    let __v_22: G = __loaded[12];
-    let __v_23: G = __loaded[13];
-    let __v_24: G = __loaded[14];
-    let __v_25: G = __loaded[15];
-    let __v_26: G = __loaded[16];
-    let __v_27: G = __loaded[17];
-    let __v_28: G = __loaded[18];
-    match __v_10.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_29: G = __loaded[0];
-        let __v_30: G = __loaded[1];
-        let __v_31: G = __loaded[2];
-        let __v_32: G = __loaded[3];
-        let __v_33: G = __loaded[4];
-        let __v_34: G = __loaded[5];
-        let __v_35: G = __loaded[6];
-        let __v_36: G = __loaded[7];
-        let __v_37: G = __loaded[8];
-        let __v_38: G = __loaded[9];
-        let __v_39: G = __loaded[10];
-        match __v_29.as_canonical_u64() {
-          1u64 => {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        match __v_0.as_canonical_u64() {
+          0u64 => {
             let __ret: [G; OUT_705] = [];
             record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_29: G = __loaded[0];
-        let __v_30: G = __loaded[1];
-        let __v_31: G = __loaded[2];
-        let __v_32: G = __loaded[3];
-        let __v_33: G = __loaded[4];
-        let __v_34: G = __loaded[5];
-        let __v_35: G = __loaded[6];
-        let __v_36: G = __loaded[7];
-        let __v_37: G = __loaded[8];
-        let __v_38: G = __loaded[9];
-        let __v_39: G = __loaded[10];
-        match __v_29.as_canonical_u64() {
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_10: G = __loaded[0];
+        let __v_11: G = __loaded[1];
+        let __v_12: G = __loaded[2];
+        let __v_13: G = __loaded[3];
+        let __v_14: G = __loaded[4];
+        let __v_15: G = __loaded[5];
+        let __v_16: G = __loaded[6];
+        let __v_17: G = __loaded[7];
+        let __v_18: G = __loaded[8];
+        let __v_19: G = __loaded[9];
+        let __v_20: G = __loaded[10];
+        let __v_21: G = __loaded[11];
+        let __v_22: G = __loaded[12];
+        let __v_23: G = __loaded[13];
+        let __v_24: G = __loaded[14];
+        let __v_25: G = __loaded[15];
+        let __v_26: G = __loaded[16];
+        let __v_27: G = __loaded[17];
+        match __v_0.as_canonical_u64() {
           0u64 => {
-            match __v_11.as_canonical_u64() {
+            let __v_28: G = G::from_u64(0);
+            let __v_29: G = G::from_u64(1);
+            if (__v_28 != __v_29) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_705] = [];
+            record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_28: G = __loaded[0];
+            let __v_29: G = __loaded[1];
+            let __v_30: G = __loaded[2];
+            let __v_31: G = __loaded[3];
+            let __v_32: G = __loaded[4];
+            let __v_33: G = __loaded[5];
+            let __v_34: G = __loaded[6];
+            let __v_35: G = __loaded[7];
+            let __v_36: G = __loaded[8];
+            let __v_37: G = __loaded[9];
+            match __v_10.as_canonical_u64() {
               _ => {
-                match __v_30.as_canonical_u64() {
+                match __v_28.as_canonical_u64() {
                   _ => {
-                    let __v_40: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_38, __v_40, __v_27]; 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)? } };
-                    if (__v_11 != __v_2) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_36, __v_26]; 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)? } };
+                    if (__v_10 != __v_2) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
                     }
-                    if (__v_12 != __v_3) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    if (__v_11 != __v_3) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
                     }
-                    if (__v_13 != __v_4) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    if (__v_12 != __v_4) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
                     }
-                    if (__v_14 != __v_5) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    if (__v_13 != __v_5) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
                     }
-                    if (__v_15 != __v_6) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    if (__v_14 != __v_6) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
                     }
-                    if (__v_16 != __v_7) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    if (__v_15 != __v_7) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
                     }
-                    if (__v_17 != __v_8) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    if (__v_16 != __v_8) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
                     }
-                    if (__v_18 != __v_9) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    if (__v_17 != __v_9) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
                     }
-                    if (__v_30 != __v_19) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    if (__v_28 != __v_18) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
                     }
-                    if (__v_31 != __v_20) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    if (__v_29 != __v_19) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
                     }
-                    if (__v_32 != __v_21) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    if (__v_30 != __v_20) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
                     }
-                    if (__v_33 != __v_22) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    if (__v_31 != __v_21) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
                     }
-                    if (__v_34 != __v_23) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    if (__v_32 != __v_22) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
                     }
-                    if (__v_35 != __v_24) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    if (__v_33 != __v_23) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
                     }
-                    if (__v_36 != __v_25) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    if (__v_34 != __v_24) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
                     }
-                    if (__v_37 != __v_26) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    if (__v_35 != __v_25) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
                     }
                     let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-                    let __v_41: G = __r_arr[0];
-                    let __v_42: G = __r_arr[1];
-                    let __v_43: G = __r_arr[2];
-                    let __v_44: G = __r_arr[3];
-                    let __v_45: G = __r_arr[4];
-                    let __v_46: G = __r_arr[5];
-                    let __v_47: G = __r_arr[6];
-                    let __v_48: G = __r_arr[7];
-                    let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_38: G = __r_arr[0];
+                    let __v_39: G = __r_arr[1];
+                    let __v_40: G = __r_arr[2];
+                    let __v_41: G = __r_arr[3];
+                    let __v_42: G = __r_arr[4];
+                    let __v_43: G = __r_arr[5];
+                    let __v_44: G = __r_arr[6];
+                    let __v_45: G = __r_arr[7];
+                    let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_37, __v_27, __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[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));
                     return Ok(__ret);
@@ -59793,14 +58660,8 @@ fn aiur_fn_705(
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-      },
     }
   })
 }
@@ -59845,8 +58706,8 @@ fn aiur_fn_706(
   })
 }
 
-const INPUT_SIZE_707: usize = 49;
-const IN_707: usize = 49;
+const INPUT_SIZE_707: usize = 48;
+const IN_707: usize = 48;
 const OUT_707: usize = 0;
 fn aiur_fn_707(
   inp: [G; IN_707],
@@ -59903,52 +58764,51 @@ fn aiur_fn_707(
     let __v_45: G = inp[45];
     let __v_46: G = inp[46];
     let __v_47: G = inp[47];
-    let __v_48: G = inp[48];
-    let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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_49: G = __r_arr[0];
-    let __v_50: G = __r_arr[1];
-    let __v_51: G = __r_arr[2];
-    let __v_52: G = __r_arr[3];
-    let __v_53: G = __r_arr[4];
-    let __v_54: G = __r_arr[5];
-    let __v_55: G = __r_arr[6];
-    let __v_56: G = __r_arr[7];
-    let __v_57: G = __r_arr[8];
-    let __v_58: G = __r_arr[9];
-    let __v_59: G = __r_arr[10];
-    let __v_60: G = __r_arr[11];
-    let __v_61: G = __r_arr[12];
-    let __v_62: G = __r_arr[13];
-    let __v_63: G = __r_arr[14];
-    let __v_64: G = __r_arr[15];
-    let __v_65: G = __r_arr[16];
-    let __v_66: G = __r_arr[17];
-    let __v_67: G = __r_arr[18];
-    let __v_68: G = __r_arr[19];
-    let __v_69: G = __r_arr[20];
-    let __v_70: G = __r_arr[21];
-    let __v_71: G = __r_arr[22];
-    let __v_72: G = __r_arr[23];
-    let __v_73: G = __r_arr[24];
-    let __v_74: G = __r_arr[25];
-    let __v_75: G = __r_arr[26];
-    let __v_76: G = __r_arr[27];
-    let __v_77: G = __r_arr[28];
-    let __v_78: G = __r_arr[29];
-    let __v_79: G = __r_arr[30];
-    let __v_80: G = __r_arr[31];
-    let __v_81: G = __r_arr[32];
-    let __v_82: G = __r_arr[33];
+    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]; 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_48: G = __r_arr[0];
+    let __v_49: G = __r_arr[1];
+    let __v_50: G = __r_arr[2];
+    let __v_51: G = __r_arr[3];
+    let __v_52: G = __r_arr[4];
+    let __v_53: G = __r_arr[5];
+    let __v_54: G = __r_arr[6];
+    let __v_55: G = __r_arr[7];
+    let __v_56: G = __r_arr[8];
+    let __v_57: G = __r_arr[9];
+    let __v_58: G = __r_arr[10];
+    let __v_59: G = __r_arr[11];
+    let __v_60: G = __r_arr[12];
+    let __v_61: G = __r_arr[13];
+    let __v_62: G = __r_arr[14];
+    let __v_63: G = __r_arr[15];
+    let __v_64: G = __r_arr[16];
+    let __v_65: G = __r_arr[17];
+    let __v_66: G = __r_arr[18];
+    let __v_67: G = __r_arr[19];
+    let __v_68: G = __r_arr[20];
+    let __v_69: G = __r_arr[21];
+    let __v_70: G = __r_arr[22];
+    let __v_71: G = __r_arr[23];
+    let __v_72: G = __r_arr[24];
+    let __v_73: G = __r_arr[25];
+    let __v_74: G = __r_arr[26];
+    let __v_75: G = __r_arr[27];
+    let __v_76: G = __r_arr[28];
+    let __v_77: G = __r_arr[29];
+    let __v_78: G = __r_arr[30];
+    let __v_79: G = __r_arr[31];
+    let __v_80: G = __r_arr[32];
+    let __v_81: G = __r_arr[33];
     match __v_9.as_canonical_u64() {
       _ => {
-        match __v_49.as_canonical_u64() {
+        match __v_48.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_49, __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_702] = { let __args: [G; IN_702] = [__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[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_702] = { let __args: [G; IN_702] = [__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[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_702] = { let __args: [G; IN_702] = [__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[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_702] = { let __args: [G; IN_702] = [__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[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_704] = { let __args: [G; IN_704] = [__v_82, __v_47, __v_48]; 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_701] = { let __args: [G; IN_701] = [__v_48, __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_702] = { let __args: [G; IN_702] = [__v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __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[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_702] = { let __args: [G; IN_702] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __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[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_702] = { let __args: [G; IN_702] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __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[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_702] = { let __args: [G; IN_702] = [__v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __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[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_704] = { let __args: [G; IN_704] = [__v_81, __v_47]; 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_707] = [];
             record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
@@ -59971,73 +58831,68 @@ fn aiur_fn_708(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 50] = { let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 50 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 50] = __args[..50].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: G = __loaded[31];
-    let __v_34: G = __loaded[32];
-    let __v_35: G = __loaded[33];
-    let __v_36: G = __loaded[34];
-    let __v_37: G = __loaded[35];
-    let __v_38: G = __loaded[36];
-    let __v_39: G = __loaded[37];
-    let __v_40: G = __loaded[38];
-    let __v_41: G = __loaded[39];
-    let __v_42: G = __loaded[40];
-    let __v_43: G = __loaded[41];
-    let __v_44: G = __loaded[42];
-    let __v_45: G = __loaded[43];
-    let __v_46: G = __loaded[44];
-    let __v_47: G = __loaded[45];
-    let __v_48: G = __loaded[46];
-    let __v_49: G = __loaded[47];
-    let __v_50: G = __loaded[48];
-    let __v_51: G = __loaded[49];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_708] = [];
         record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__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[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_708] = { let __args: [G; IN_708] = [__v_0, __v_51]; 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 __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __v_11: G = __loaded[9];
+        let __v_12: G = __loaded[10];
+        let __v_13: G = __loaded[11];
+        let __v_14: G = __loaded[12];
+        let __v_15: G = __loaded[13];
+        let __v_16: G = __loaded[14];
+        let __v_17: G = __loaded[15];
+        let __v_18: G = __loaded[16];
+        let __v_19: G = __loaded[17];
+        let __v_20: G = __loaded[18];
+        let __v_21: G = __loaded[19];
+        let __v_22: G = __loaded[20];
+        let __v_23: G = __loaded[21];
+        let __v_24: G = __loaded[22];
+        let __v_25: G = __loaded[23];
+        let __v_26: G = __loaded[24];
+        let __v_27: G = __loaded[25];
+        let __v_28: G = __loaded[26];
+        let __v_29: G = __loaded[27];
+        let __v_30: G = __loaded[28];
+        let __v_31: G = __loaded[29];
+        let __v_32: G = __loaded[30];
+        let __v_33: G = __loaded[31];
+        let __v_34: G = __loaded[32];
+        let __v_35: G = __loaded[33];
+        let __v_36: G = __loaded[34];
+        let __v_37: G = __loaded[35];
+        let __v_38: G = __loaded[36];
+        let __v_39: G = __loaded[37];
+        let __v_40: G = __loaded[38];
+        let __v_41: G = __loaded[39];
+        let __v_42: G = __loaded[40];
+        let __v_43: G = __loaded[41];
+        let __v_44: G = __loaded[42];
+        let __v_45: G = __loaded[43];
+        let __v_46: G = __loaded[44];
+        let __v_47: G = __loaded[45];
+        let __v_48: G = __loaded[46];
+        let __v_49: G = __loaded[47];
+        let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_708] = { let __args: [G; IN_708] = [__v_0, __v_49]; 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);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -60074,8 +58929,8 @@ fn aiur_fn_709(
   })
 }
 
-const INPUT_SIZE_710: usize = 99;
-const IN_710: usize = 99;
+const INPUT_SIZE_710: usize = 98;
+const IN_710: usize = 98;
 const OUT_710: usize = 0;
 fn aiur_fn_710(
   inp: [G; IN_710],
@@ -60182,7 +59037,6 @@ fn aiur_fn_710(
     let __v_95: G = inp[95];
     let __v_96: G = inp[96];
     let __v_97: G = inp[97];
-    let __v_98: G = inp[98];
     match __v_0.as_canonical_u64() {
       0u64 => {
         match __v_45.as_canonical_u64() {
@@ -60192,8 +59046,8 @@ fn aiur_fn_710(
                 let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_1, __v_46, __v_47]; 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_699] = { let __args: [G; IN_699] = [__v_2, __v_48, __v_49]; 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_702] = { let __args: [G; IN_702] = [__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[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_704] = { let __args: [G; IN_704] = [__v_11, __v_59, __v_60]; 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_12, __v_61, __v_62]; 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_11, __v_59]; 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_12, __v_60]; 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_710] = [];
                 record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -60214,8 +59068,8 @@ fn aiur_fn_710(
                 let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__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[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_702] = { let __args: [G; IN_702] = [__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[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_702] = { let __args: [G; IN_702] = [__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[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_704] = { let __args: [G; IN_704] = [__v_26, __v_75, __v_76]; 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_709] = { let __args: [G; IN_709] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_26, __v_75]; 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_709] = { let __args: [G; IN_709] = [__v_27, __v_76, __v_77]; 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);
@@ -60239,8 +59093,8 @@ fn aiur_fn_710(
                 let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__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[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_702] = { let __args: [G; IN_702] = [__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[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_702] = { let __args: [G; IN_702] = [__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[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_704] = { let __args: [G; IN_704] = [__v_43, __v_95, __v_96]; 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_706] = { let __args: [G; IN_706] = [__v_44, __v_97, __v_98]; 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_704] = { let __args: [G; IN_704] = [__v_43, __v_95]; 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_706] = { let __args: [G; IN_706] = [__v_44, __v_96, __v_97]; 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_710] = [];
                 record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -60271,139 +59125,134 @@ fn aiur_fn_711(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 64] = { let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 64 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 64] = __args[..64].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: G = __loaded[31];
-    let __v_34: G = __loaded[32];
-    let __v_35: G = __loaded[33];
-    let __v_36: G = __loaded[34];
-    let __v_37: G = __loaded[35];
-    let __v_38: G = __loaded[36];
-    let __v_39: G = __loaded[37];
-    let __v_40: G = __loaded[38];
-    let __v_41: G = __loaded[39];
-    let __v_42: G = __loaded[40];
-    let __v_43: G = __loaded[41];
-    let __v_44: G = __loaded[42];
-    let __v_45: G = __loaded[43];
-    let __v_46: G = __loaded[44];
-    let __v_47: G = __loaded[45];
-    let __v_48: G = __loaded[46];
-    let __v_49: G = __loaded[47];
-    let __v_50: G = __loaded[48];
-    let __v_51: G = __loaded[49];
-    let __v_52: G = __loaded[50];
-    let __v_53: G = __loaded[51];
-    let __v_54: G = __loaded[52];
-    let __v_55: G = __loaded[53];
-    let __v_56: G = __loaded[54];
-    let __v_57: G = __loaded[55];
-    let __v_58: G = __loaded[56];
-    let __v_59: G = __loaded[57];
-    let __v_60: G = __loaded[58];
-    let __v_61: G = __loaded[59];
-    let __v_62: G = __loaded[60];
-    let __v_63: G = __loaded[61];
-    let __v_64: G = __loaded[62];
-    let __v_65: G = __loaded[63];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_711] = [];
         record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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_66: G = __r_arr[0];
-        let __v_67: G = __r_arr[1];
-        let __v_68: G = __r_arr[2];
-        let __v_69: G = __r_arr[3];
-        let __v_70: G = __r_arr[4];
-        let __v_71: G = __r_arr[5];
-        let __v_72: G = __r_arr[6];
-        let __v_73: G = __r_arr[7];
-        let __v_74: G = __r_arr[8];
-        let __v_75: G = __r_arr[9];
-        let __v_76: G = __r_arr[10];
-        let __v_77: G = __r_arr[11];
-        let __v_78: G = __r_arr[12];
-        let __v_79: G = __r_arr[13];
-        let __v_80: G = __r_arr[14];
-        let __v_81: G = __r_arr[15];
-        let __v_82: G = __r_arr[16];
-        let __v_83: G = __r_arr[17];
-        let __v_84: G = __r_arr[18];
-        let __v_85: G = __r_arr[19];
-        let __v_86: G = __r_arr[20];
-        let __v_87: G = __r_arr[21];
-        let __v_88: G = __r_arr[22];
-        let __v_89: G = __r_arr[23];
-        let __v_90: G = __r_arr[24];
-        let __v_91: G = __r_arr[25];
-        let __v_92: G = __r_arr[26];
-        let __v_93: G = __r_arr[27];
-        let __v_94: G = __r_arr[28];
-        let __v_95: G = __r_arr[29];
-        let __v_96: G = __r_arr[30];
-        let __v_97: G = __r_arr[31];
-        let __v_98: G = __r_arr[32];
-        let __v_99: G = __r_arr[33];
-        let __v_100: G = __r_arr[34];
-        let __v_101: G = __r_arr[35];
-        let __v_102: G = __r_arr[36];
-        let __v_103: G = __r_arr[37];
-        let __v_104: G = __r_arr[38];
-        let __v_105: G = __r_arr[39];
-        let __v_106: G = __r_arr[40];
-        let __v_107: G = __r_arr[41];
-        let __v_108: G = __r_arr[42];
-        let __v_109: G = __r_arr[43];
-        let __v_110: G = __r_arr[44];
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__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[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_65]; 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 __loaded: [G; 62] = { let __mq = record.memory_queries.get_mut(&62).ok_or(ExecError::InvalidMemorySize(62))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 62 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 62] = __args[..62].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __v_11: G = __loaded[9];
+        let __v_12: G = __loaded[10];
+        let __v_13: G = __loaded[11];
+        let __v_14: G = __loaded[12];
+        let __v_15: G = __loaded[13];
+        let __v_16: G = __loaded[14];
+        let __v_17: G = __loaded[15];
+        let __v_18: G = __loaded[16];
+        let __v_19: G = __loaded[17];
+        let __v_20: G = __loaded[18];
+        let __v_21: G = __loaded[19];
+        let __v_22: G = __loaded[20];
+        let __v_23: G = __loaded[21];
+        let __v_24: G = __loaded[22];
+        let __v_25: G = __loaded[23];
+        let __v_26: G = __loaded[24];
+        let __v_27: G = __loaded[25];
+        let __v_28: G = __loaded[26];
+        let __v_29: G = __loaded[27];
+        let __v_30: G = __loaded[28];
+        let __v_31: G = __loaded[29];
+        let __v_32: G = __loaded[30];
+        let __v_33: G = __loaded[31];
+        let __v_34: G = __loaded[32];
+        let __v_35: G = __loaded[33];
+        let __v_36: G = __loaded[34];
+        let __v_37: G = __loaded[35];
+        let __v_38: G = __loaded[36];
+        let __v_39: G = __loaded[37];
+        let __v_40: G = __loaded[38];
+        let __v_41: G = __loaded[39];
+        let __v_42: G = __loaded[40];
+        let __v_43: G = __loaded[41];
+        let __v_44: G = __loaded[42];
+        let __v_45: G = __loaded[43];
+        let __v_46: G = __loaded[44];
+        let __v_47: G = __loaded[45];
+        let __v_48: G = __loaded[46];
+        let __v_49: G = __loaded[47];
+        let __v_50: G = __loaded[48];
+        let __v_51: G = __loaded[49];
+        let __v_52: G = __loaded[50];
+        let __v_53: G = __loaded[51];
+        let __v_54: G = __loaded[52];
+        let __v_55: G = __loaded[53];
+        let __v_56: G = __loaded[54];
+        let __v_57: G = __loaded[55];
+        let __v_58: G = __loaded[56];
+        let __v_59: G = __loaded[57];
+        let __v_60: G = __loaded[58];
+        let __v_61: G = __loaded[59];
+        let __v_62: G = __loaded[60];
+        let __v_63: G = __loaded[61];
+        let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0, __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_64: G = __r_arr[0];
+        let __v_65: G = __r_arr[1];
+        let __v_66: G = __r_arr[2];
+        let __v_67: G = __r_arr[3];
+        let __v_68: G = __r_arr[4];
+        let __v_69: G = __r_arr[5];
+        let __v_70: G = __r_arr[6];
+        let __v_71: G = __r_arr[7];
+        let __v_72: G = __r_arr[8];
+        let __v_73: G = __r_arr[9];
+        let __v_74: G = __r_arr[10];
+        let __v_75: G = __r_arr[11];
+        let __v_76: G = __r_arr[12];
+        let __v_77: G = __r_arr[13];
+        let __v_78: G = __r_arr[14];
+        let __v_79: G = __r_arr[15];
+        let __v_80: G = __r_arr[16];
+        let __v_81: G = __r_arr[17];
+        let __v_82: G = __r_arr[18];
+        let __v_83: G = __r_arr[19];
+        let __v_84: G = __r_arr[20];
+        let __v_85: G = __r_arr[21];
+        let __v_86: G = __r_arr[22];
+        let __v_87: G = __r_arr[23];
+        let __v_88: G = __r_arr[24];
+        let __v_89: G = __r_arr[25];
+        let __v_90: G = __r_arr[26];
+        let __v_91: G = __r_arr[27];
+        let __v_92: G = __r_arr[28];
+        let __v_93: G = __r_arr[29];
+        let __v_94: G = __r_arr[30];
+        let __v_95: G = __r_arr[31];
+        let __v_96: G = __r_arr[32];
+        let __v_97: G = __r_arr[33];
+        let __v_98: G = __r_arr[34];
+        let __v_99: G = __r_arr[35];
+        let __v_100: G = __r_arr[36];
+        let __v_101: G = __r_arr[37];
+        let __v_102: G = __r_arr[38];
+        let __v_103: G = __r_arr[39];
+        let __v_104: G = __r_arr[40];
+        let __v_105: G = __r_arr[41];
+        let __v_106: G = __r_arr[42];
+        let __v_107: G = __r_arr[43];
+        let __v_108: G = __r_arr[44];
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__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_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
         let __ret: [G; OUT_711] = [];
         record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_712: usize = 55;
-const IN_712: usize = 55;
+const INPUT_SIZE_712: usize = 54;
+const IN_712: usize = 54;
 const OUT_712: usize = 0;
 fn aiur_fn_712(
   inp: [G; IN_712],
@@ -60466,69 +59315,68 @@ fn aiur_fn_712(
     let __v_51: G = inp[51];
     let __v_52: G = inp[52];
     let __v_53: G = inp[53];
-    let __v_54: G = inp[54];
     let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0]; 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_55: G = __r_arr[0];
-    let __v_56: G = __r_arr[1];
-    let __v_57: G = __r_arr[2];
-    let __v_58: G = __r_arr[3];
-    let __v_59: G = __r_arr[4];
-    let __v_60: G = __r_arr[5];
-    let __v_61: G = __r_arr[6];
-    let __v_62: G = __r_arr[7];
-    let __v_63: G = __r_arr[8];
-    let __v_64: G = __r_arr[9];
-    let __v_65: G = __r_arr[10];
-    let __v_66: G = __r_arr[11];
-    let __v_67: G = __r_arr[12];
-    let __v_68: G = __r_arr[13];
-    let __v_69: G = __r_arr[14];
-    let __v_70: G = __r_arr[15];
-    let __v_71: G = __r_arr[16];
-    let __v_72: G = __r_arr[17];
-    let __v_73: G = __r_arr[18];
-    let __v_74: G = __r_arr[19];
-    let __v_75: G = __r_arr[20];
-    let __v_76: G = __r_arr[21];
-    let __v_77: G = __r_arr[22];
-    let __v_78: G = __r_arr[23];
-    let __v_79: G = __r_arr[24];
-    let __v_80: G = __r_arr[25];
-    let __v_81: G = __r_arr[26];
-    let __v_82: G = __r_arr[27];
-    let __v_83: G = __r_arr[28];
-    let __v_84: G = __r_arr[29];
-    let __v_85: G = __r_arr[30];
-    let __v_86: G = __r_arr[31];
-    let __v_87: G = __r_arr[32];
-    let __v_88: G = __r_arr[33];
-    let __v_89: G = __r_arr[34];
-    let __v_90: G = __r_arr[35];
-    let __v_91: G = __r_arr[36];
-    let __v_92: G = __r_arr[37];
-    let __v_93: G = __r_arr[38];
-    let __v_94: G = __r_arr[39];
-    let __v_95: G = __r_arr[40];
-    let __v_96: G = __r_arr[41];
-    let __v_97: G = __r_arr[42];
-    let __v_98: G = __r_arr[43];
-    let __v_99: G = __r_arr[44];
-    let __v_100: G = __r_arr[45];
-    let __v_101: G = __r_arr[46];
-    let __v_102: G = __r_arr[47];
-    match __v_55.as_canonical_u64() {
-      _ => {
-        match __v_55.as_canonical_u64() {
+    let __v_54: G = __r_arr[0];
+    let __v_55: G = __r_arr[1];
+    let __v_56: G = __r_arr[2];
+    let __v_57: G = __r_arr[3];
+    let __v_58: G = __r_arr[4];
+    let __v_59: G = __r_arr[5];
+    let __v_60: G = __r_arr[6];
+    let __v_61: G = __r_arr[7];
+    let __v_62: G = __r_arr[8];
+    let __v_63: G = __r_arr[9];
+    let __v_64: G = __r_arr[10];
+    let __v_65: G = __r_arr[11];
+    let __v_66: G = __r_arr[12];
+    let __v_67: G = __r_arr[13];
+    let __v_68: G = __r_arr[14];
+    let __v_69: G = __r_arr[15];
+    let __v_70: G = __r_arr[16];
+    let __v_71: G = __r_arr[17];
+    let __v_72: G = __r_arr[18];
+    let __v_73: G = __r_arr[19];
+    let __v_74: G = __r_arr[20];
+    let __v_75: G = __r_arr[21];
+    let __v_76: G = __r_arr[22];
+    let __v_77: G = __r_arr[23];
+    let __v_78: G = __r_arr[24];
+    let __v_79: G = __r_arr[25];
+    let __v_80: G = __r_arr[26];
+    let __v_81: G = __r_arr[27];
+    let __v_82: G = __r_arr[28];
+    let __v_83: G = __r_arr[29];
+    let __v_84: G = __r_arr[30];
+    let __v_85: G = __r_arr[31];
+    let __v_86: G = __r_arr[32];
+    let __v_87: G = __r_arr[33];
+    let __v_88: G = __r_arr[34];
+    let __v_89: G = __r_arr[35];
+    let __v_90: G = __r_arr[36];
+    let __v_91: G = __r_arr[37];
+    let __v_92: G = __r_arr[38];
+    let __v_93: G = __r_arr[39];
+    let __v_94: G = __r_arr[40];
+    let __v_95: G = __r_arr[41];
+    let __v_96: G = __r_arr[42];
+    let __v_97: G = __r_arr[43];
+    let __v_98: G = __r_arr[44];
+    let __v_99: G = __r_arr[45];
+    let __v_100: G = __r_arr[46];
+    let __v_101: G = __r_arr[47];
+    match __v_54.as_canonical_u64() {
+      _ => {
+        match __v_54.as_canonical_u64() {
           0u64 => {
             match __v_1.as_canonical_u64() {
               0u64 => {
-                match __v_56.as_canonical_u64() {
+                match __v_55.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_56, __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_699] = { let __args: [G; IN_699] = [__v_57, __v_4, __v_5]; 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_702] = { let __args: [G; IN_702] = [__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[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_704] = { let __args: [G; IN_704] = [__v_66, __v_15, __v_16]; 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_67, __v_17, __v_18]; 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_698] = { let __args: [G; IN_698] = [__v_55, __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_699] = { let __args: [G; IN_699] = [__v_56, __v_4, __v_5]; 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_702] = { let __args: [G; IN_702] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __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[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_704] = { let __args: [G; IN_704] = [__v_65, __v_15]; 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_66, __v_16]; 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_712] = [];
                     record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -60543,17 +59391,17 @@ fn aiur_fn_712(
           1u64 => {
             match __v_1.as_canonical_u64() {
               1u64 => {
-                match __v_56.as_canonical_u64() {
+                match __v_55.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_57, __v_4, __v_5]; 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_702] = { let __args: [G; IN_702] = [__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[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_702] = { let __args: [G; IN_702] = [__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[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_702] = { let __args: [G; IN_702] = [__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[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_702] = { let __args: [G; IN_702] = [__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[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_702] = { let __args: [G; IN_702] = [__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[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_704] = { let __args: [G; IN_704] = [__v_98, __v_51, __v_52]; 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_706] = { let __args: [G; IN_706] = [__v_99, __v_53, __v_54]; 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_701] = { let __args: [G; IN_701] = [__v_55, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_56, __v_4, __v_5]; 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_702] = { let __args: [G; IN_702] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __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[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_702] = { let __args: [G; IN_702] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __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[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_702] = { let __args: [G; IN_702] = [__v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __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[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_702] = { let __args: [G; IN_702] = [__v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __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[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_702] = { let __args: [G; IN_702] = [__v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __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[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_704] = { let __args: [G; IN_704] = [__v_97, __v_51]; 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_706] = { let __args: [G; IN_706] = [__v_98, __v_52, __v_53]; 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_712] = [];
                     record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -60568,11 +59416,11 @@ fn aiur_fn_712(
           2u64 => {
             match __v_1.as_canonical_u64() {
               2u64 => {
-                match __v_56.as_canonical_u64() {
+                match __v_55.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__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[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_704] = { let __args: [G; IN_704] = [__v_65, __v_13, __v_14]; 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_701] = { let __args: [G; IN_701] = [__v_55, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __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[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_704] = { let __args: [G; IN_704] = [__v_64, __v_13]; 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_712] = [];
                     record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -60587,11 +59435,11 @@ fn aiur_fn_712(
           3u64 => {
             match __v_1.as_canonical_u64() {
               3u64 => {
-                match __v_56.as_canonical_u64() {
+                match __v_55.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__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[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_704] = { let __args: [G; IN_704] = [__v_65, __v_13, __v_14]; 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_700] = { let __args: [G; IN_700] = [__v_55, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __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[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_704] = { let __args: [G; IN_704] = [__v_64, __v_13]; 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_712] = [];
                     record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -60606,11 +59454,11 @@ fn aiur_fn_712(
           4u64 => {
             match __v_1.as_canonical_u64() {
               4u64 => {
-                match __v_56.as_canonical_u64() {
+                match __v_55.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__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[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_702] = { let __args: [G; IN_702] = [__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[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_703] = { let __args: [G; IN_703] = [__v_72, __v_20, __v_21]; 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_702] = { let __args: [G; IN_702] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __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[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_702] = { let __args: [G; IN_702] = [__v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __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[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_703] = { let __args: [G; IN_703] = [__v_71, __v_20]; 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_712] = [];
                     record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -60625,10 +59473,10 @@ fn aiur_fn_712(
           5u64 => {
             match __v_1.as_canonical_u64() {
               5u64 => {
-                match __v_56.as_canonical_u64() {
+                match __v_55.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__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[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_703] = { let __args: [G; IN_703] = [__v_64, __v_11, __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_702] = { let __args: [G; IN_702] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __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[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_703] = { let __args: [G; IN_703] = [__v_63, __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 __ret: [G; OUT_712] = [];
                     record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -60643,10 +59491,10 @@ fn aiur_fn_712(
           6u64 => {
             match __v_1.as_canonical_u64() {
               6u64 => {
-                match __v_56.as_canonical_u64() {
+                match __v_55.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__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[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_703] = { let __args: [G; IN_703] = [__v_64, __v_11, __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_702] = { let __args: [G; IN_702] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __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[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_703] = { let __args: [G; IN_703] = [__v_63, __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 __ret: [G; OUT_712] = [];
                     record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -60661,10 +59509,10 @@ fn aiur_fn_712(
           7u64 => {
             match __v_1.as_canonical_u64() {
               7u64 => {
-                match __v_56.as_canonical_u64() {
+                match __v_55.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__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[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_703] = { let __args: [G; IN_703] = [__v_64, __v_11, __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_702] = { let __args: [G; IN_702] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __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[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_703] = { let __args: [G; IN_703] = [__v_63, __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 __ret: [G; OUT_712] = [];
                     record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
@@ -60679,7 +59527,7 @@ fn aiur_fn_712(
           8u64 => {
             match __v_1.as_canonical_u64() {
               8u64 => {
-                let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_55, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
                 let __ret: [G; OUT_712] = [];
                 record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
@@ -60690,7 +59538,7 @@ fn aiur_fn_712(
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_54.as_canonical_u64()));
           },
         }
       },
@@ -60807,37 +59655,30 @@ fn aiur_fn_714(
         let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_56]; 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_57: G = __r_arr[0];
         let __v_58: G = __r_arr[1];
-        let __v_59: G = __r_arr[2];
         match __v_57.as_canonical_u64() {
-          1u64 => {
+          0u64 => {
             let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } };
             let __ret: [G; OUT_714] = [];
             record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_58]; 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_60: G = __r_arr[0];
-            let __v_61: G = G::from_u64(1);
-            let __v_62: G = G::from_u64(1);
-            let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_60, __v_61, __v_62, __v_62, __v_62, __v_62, __v_62]; 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_63: G = __r_arr[0];
-            let __v_64: G = __r_arr[1];
-            let __v_65: G = __r_arr[2];
-            let __v_66: G = __r_arr[3];
-            let __v_67: G = __r_arr[4];
-            let __v_68: G = __r_arr[5];
-            let __v_69: G = G::from_u64(1);
-            let __v_70: G = G::from_u64(1);
-            let __v_71: G = G::from_u64(0);
-            let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_55, __v_69, __v_70, __v_70, __v_70, __v_70, __v_70, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_673] = { let __args: [G; IN_673] = [__v_57]; 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_59: G = __r_arr[0];
+            let __v_60: G = G::from_u64(0);
+            let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_59, __v_60, __v_60, __v_60, __v_60, __v_60]; 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_61: G = __r_arr[0];
+            let __v_62: G = __r_arr[1];
+            let __v_63: G = __r_arr[2];
+            let __v_64: G = __r_arr[3];
+            let __v_65: G = __r_arr[4];
+            let __v_66: G = G::from_u64(0);
+            let __v_67: G = G::from_u64(0);
+            let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_55, __v_66, __v_66, __v_66, __v_66, __v_66, __v_61, __v_62, __v_63, __v_64, __v_65, __v_67]; 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 __ret: [G; OUT_714] = [];
             record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_57.as_canonical_u64()));
-          },
         }
       },
       5u64 => {
@@ -60847,8 +59688,7 @@ fn aiur_fn_714(
         let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_56]; 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_57: G = __r_arr[0];
         let __v_58: G = __r_arr[1];
-        let __v_59: G = __r_arr[2];
-        let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_55, __v_57, __v_58]; 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_679] = { let __args: [G; IN_679] = [__v_55, __v_57]; 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 __ret: [G; OUT_714] = [];
         record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -60912,8 +59752,7 @@ fn aiur_fn_714(
         let __v_108: G = __r_arr[51];
         let __v_109: G = __r_arr[52];
         let __v_110: G = __r_arr[53];
-        let __v_111: G = __r_arr[54];
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; 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_714] = [];
         record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
@@ -60999,26 +59838,22 @@ fn aiur_fn_716(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_1]; 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_736] = { let __args: [G; IN_736] = [__v_0, __v_1]; 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_3: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
+    match __v_3.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_716] = [__v_2];
         record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __ret: [G; OUT_716] = [__v_5];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __ret: [G; OUT_716] = [__v_4];
         record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
     }
   })
 }
@@ -61035,32 +59870,24 @@ fn aiur_fn_717(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_9: G = { let __values: [G; 3] = [__v_5, __v_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_717] = [__v_9];
-        record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
-        let __v_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_717] = [__v_7];
+        let __v_2: G = G::from_u64(0);
+        let __v_3: 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_717] = [__v_3];
         record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = { let __values: [G; 2] = [__v_2, __v_4]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_717] = [__v_5];
+        record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -61077,63 +59904,59 @@ fn aiur_fn_718(
 ) -> Result<[G; OUT_718], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = G::from_u64(0);
-        let __v_16: G = G::from_u64(0);
-        let __v_17: G = G::from_u64(0);
-        let __v_18: G = G::from_u64(0);
-        let __ret: [G; OUT_718] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
-        record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = __r_arr[1];
-        let __v_13: G = __r_arr[2];
-        let __v_14: G = __r_arr[3];
-        let __v_15: G = __r_arr[4];
-        let __v_16: G = __r_arr[5];
-        let __v_17: G = __r_arr[6];
-        let __v_18: G = __r_arr[7];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __v_20: G = __r_arr[1];
-        let __v_21: G = __r_arr[2];
-        let __v_22: G = __r_arr[3];
-        let __v_23: G = __r_arr[4];
-        let __v_24: G = __r_arr[5];
-        let __v_25: G = __r_arr[6];
-        let __v_26: G = __r_arr[7];
-        let __ret: [G; OUT_718] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_718] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
         record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = __r_arr[1];
+        let __v_12: G = __r_arr[2];
+        let __v_13: G = __r_arr[3];
+        let __v_14: G = __r_arr[4];
+        let __v_15: G = __r_arr[5];
+        let __v_16: G = __r_arr[6];
+        let __v_17: G = __r_arr[7];
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __v_18: G = __r_arr[0];
+        let __v_19: G = __r_arr[1];
+        let __v_20: G = __r_arr[2];
+        let __v_21: G = __r_arr[3];
+        let __v_22: G = __r_arr[4];
+        let __v_23: G = __r_arr[5];
+        let __v_24: G = __r_arr[6];
+        let __v_25: G = __r_arr[7];
+        let __ret: [G; OUT_718] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_719: usize = 2;
-const IN_719: usize = 2;
+const INPUT_SIZE_719: usize = 1;
+const IN_719: usize = 1;
 const OUT_719: usize = 1;
 fn aiur_fn_719(
   inp: [G; IN_719],
@@ -61143,37 +59966,35 @@ fn aiur_fn_719(
 ) -> Result<[G; OUT_719], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
         let __ret: [G; OUT_719] = [__v_1];
         record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_5, __v_1]; 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_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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } };
+        let __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_719] = [__v_8];
         record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_720: usize = 1;
-const IN_720: usize = 1;
-const OUT_720: usize = 8;
+const INPUT_SIZE_720: usize = 5;
+const IN_720: usize = 5;
+const OUT_720: usize = 1;
 fn aiur_fn_720(
   inp: [G; IN_720],
   record: &mut QueryRecord,
@@ -61182,56 +60003,38 @@ fn aiur_fn_720(
 ) -> Result<[G; OUT_720], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(0);
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_720] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        let __v_6: G = { let __values: [G; 5] = [__v_1, __v_2, __v_3, __v_4, __v_5]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_720] = [__v_6];
         record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __v_5: G = __r_arr[1];
-        let __v_6: G = __r_arr[2];
-        let __v_7: G = __r_arr[3];
-        let __v_8: G = __r_arr[4];
-        let __v_9: G = __r_arr[5];
-        let __v_10: G = __r_arr[6];
-        let __v_11: G = __r_arr[7];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __v_13: G = __r_arr[1];
-        let __v_14: G = __r_arr[2];
-        let __v_15: G = __r_arr[3];
-        let __v_16: G = __r_arr[4];
-        let __v_17: G = __r_arr[5];
-        let __v_18: G = __r_arr[6];
-        let __v_19: G = __r_arr[7];
-        let __ret: [G; OUT_720] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        let __v_9: G = __loaded[4];
+        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = { let __values: [G; 5] = [__v_5, __v_6, __v_7, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_720] = [__v_11];
         record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_721: usize = 8;
-const IN_721: usize = 8;
+const INPUT_SIZE_721: usize = 2;
+const IN_721: usize = 2;
 const OUT_721: usize = 1;
 fn aiur_fn_721(
   inp: [G; IN_721],
@@ -61242,63 +60045,23 @@ fn aiur_fn_721(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_721] = [__v_7];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_721] = [__v_1];
         record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-        let __v_8: G = __loaded[0];
-        let __v_9: G = __loaded[1];
-        let __v_10: G = __loaded[2];
-        let __v_11: G = __loaded[3];
-        let __v_12: G = __loaded[4];
-        let __v_13: G = __loaded[5];
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-        let __v_14: G = __loaded[0];
-        let __v_15: G = __loaded[1];
-        let __v_16: G = __loaded[2];
-        let __v_17: G = __loaded[3];
-        let __v_18: G = __loaded[4];
-        let __v_19: G = __loaded[5];
-        let __v_20: G = { 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_721] = { let __args: [G; IN_721] = [__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[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_21: G = __r_arr[0];
-            let __ret: [G; OUT_721] = [__v_21];
-            record.function_queries[721].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_721] = [__v_4];
-                record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__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[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_22: G = __r_arr[0];
-                let __ret: [G; OUT_721] = [__v_22];
-                record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-        }
-      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = { let __values: [G; 3] = [__v_2, __v_3, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_721] = [__v_6];
+        record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -61306,7 +60069,7 @@ fn aiur_fn_721(
 
 const INPUT_SIZE_722: usize = 1;
 const IN_722: usize = 1;
-const OUT_722: usize = 1;
+const OUT_722: usize = 8;
 fn aiur_fn_722(
   inp: [G; IN_722],
   record: &mut QueryRecord,
@@ -61315,19 +60078,52 @@ fn aiur_fn_722(
 ) -> Result<[G; OUT_722], 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_740] = { let __args: [G; IN_740] = [__v_0, __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 __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_722] = [__v_4];
-    record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_722] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __v_5: G = __r_arr[2];
+        let __v_6: G = __r_arr[3];
+        let __v_7: G = __r_arr[4];
+        let __v_8: G = __r_arr[5];
+        let __v_9: G = __r_arr[6];
+        let __v_10: G = __r_arr[7];
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = __r_arr[1];
+        let __v_13: G = __r_arr[2];
+        let __v_14: G = __r_arr[3];
+        let __v_15: G = __r_arr[4];
+        let __v_16: G = __r_arr[5];
+        let __v_17: G = __r_arr[6];
+        let __v_18: G = __r_arr[7];
+        let __ret: [G; OUT_722] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
+        record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_723: usize = 2;
-const IN_723: usize = 2;
+const INPUT_SIZE_723: usize = 7;
+const IN_723: usize = 7;
 const OUT_723: usize = 1;
 fn aiur_fn_723(
   inp: [G; IN_723],
@@ -61338,27 +60134,57 @@ fn aiur_fn_723(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_723] = [__v_1];
-        record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    match __v_4.as_canonical_u64() {
       0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = { 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_723] = [__v_7];
+        let __ret: [G; OUT_723] = [__v_6];
         record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __v_16: G = __loaded[4];
+        let __v_17: G = { 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_17.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_6]; 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_18: G = __r_arr[0];
+            let __ret: [G; OUT_723] = [__v_18];
+            record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_18: G = (__v_0 - __v_2);
+            match __v_18.as_canonical_u64() {
+              0u64 => {
+                let __ret: [G; OUT_723] = [__v_3];
+                record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_0, __v_12, __v_13, __v_14, __v_15, __v_16, __v_6]; 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_19: G = __r_arr[0];
+                let __ret: [G; OUT_723] = [__v_19];
+                record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
       },
     }
   })
@@ -61375,36 +60201,18 @@ fn aiur_fn_724(
 ) -> Result<[G; OUT_724], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_724] = [__v_4];
-        record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_3]; 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_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_724] = [__v_6];
-        record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
+    let __v_1: G = G::from_u64(0);
+    let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __ret: [G; OUT_724] = [__v_2];
+    record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_725: usize = 1;
-const IN_725: usize = 1;
-const OUT_725: usize = 8;
+const INPUT_SIZE_725: usize = 2;
+const IN_725: usize = 2;
+const OUT_725: usize = 1;
 fn aiur_fn_725(
   inp: [G; IN_725],
   record: &mut QueryRecord,
@@ -61413,90 +60221,31 @@ fn aiur_fn_725(
 ) -> Result<[G; OUT_725], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    let __v_11: G = __loaded[10];
-    let __v_12: G = __loaded[11];
-    let __v_13: G = __loaded[12];
-    let __v_14: G = __loaded[13];
-    let __v_15: G = __loaded[14];
-    let __v_16: G = __loaded[15];
-    let __v_17: G = __loaded[16];
-    let __v_18: G = __loaded[17];
-    let __v_19: G = __loaded[18];
-    let __v_20: G = __loaded[19];
-    let __v_21: G = __loaded[20];
-    let __v_22: G = __loaded[21];
-    let __v_23: G = __loaded[22];
-    let __v_24: G = __loaded[23];
-    let __v_25: G = __loaded[24];
-    let __v_26: G = __loaded[25];
-    let __v_27: G = __loaded[26];
-    let __v_28: G = __loaded[27];
-    let __v_29: G = __loaded[28];
-    let __v_30: G = __loaded[29];
-    let __v_31: G = __loaded[30];
-    let __v_32: G = __loaded[31];
-    let __v_33: G = __loaded[32];
-    let __v_34: G = __loaded[33];
-    let __v_35: G = __loaded[34];
-    let __v_36: G = __loaded[35];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_37: G = G::from_u64(0);
-        let __v_38: G = G::from_u64(0);
-        let __v_39: G = G::from_u64(0);
-        let __v_40: G = G::from_u64(0);
-        let __v_41: G = G::from_u64(0);
-        let __v_42: G = G::from_u64(0);
-        let __v_43: G = G::from_u64(0);
-        let __v_44: G = G::from_u64(0);
-        let __ret: [G; OUT_725] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44];
-        record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __v_1: G = inp[1];
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_36]; 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_37: G = __r_arr[0];
-        let __v_38: G = __r_arr[1];
-        let __v_39: G = __r_arr[2];
-        let __v_40: G = __r_arr[3];
-        let __v_41: G = __r_arr[4];
-        let __v_42: G = __r_arr[5];
-        let __v_43: G = __r_arr[6];
-        let __v_44: G = __r_arr[7];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_45: G = __r_arr[0];
-        let __v_46: G = __r_arr[1];
-        let __v_47: G = __r_arr[2];
-        let __v_48: G = __r_arr[3];
-        let __v_49: G = __r_arr[4];
-        let __v_50: G = __r_arr[5];
-        let __v_51: G = __r_arr[6];
-        let __v_52: G = __r_arr[7];
-        let __ret: [G; OUT_725] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52];
+        let __ret: [G; OUT_725] = [__v_1];
         record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_3, __v_1]; 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_4: G = __r_arr[0];
+        let __v_5: G = { let __values: [G; 2] = [__v_2, __v_4]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_725] = [__v_5];
+        record.function_queries[725].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 = 1;
+const INPUT_SIZE_726: usize = 1;
+const IN_726: usize = 1;
+const OUT_726: usize = 8;
 fn aiur_fn_726(
   inp: [G; IN_726],
   record: &mut QueryRecord,
@@ -61505,28 +60254,85 @@ fn aiur_fn_726(
 ) -> 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];
-    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_726] = [__v_4];
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_726] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
         record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        let __loaded: [G; 35] = { let __mq = record.memory_queries.get_mut(&35).ok_or(ExecError::InvalidMemorySize(35))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 35 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 35] = __args[..35].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __v_10: G = __loaded[9];
+        let __v_11: G = __loaded[10];
+        let __v_12: G = __loaded[11];
+        let __v_13: G = __loaded[12];
+        let __v_14: G = __loaded[13];
+        let __v_15: G = __loaded[14];
+        let __v_16: G = __loaded[15];
+        let __v_17: G = __loaded[16];
+        let __v_18: G = __loaded[17];
+        let __v_19: G = __loaded[18];
+        let __v_20: G = __loaded[19];
+        let __v_21: G = __loaded[20];
+        let __v_22: G = __loaded[21];
+        let __v_23: G = __loaded[22];
+        let __v_24: G = __loaded[23];
+        let __v_25: G = __loaded[24];
+        let __v_26: G = __loaded[25];
+        let __v_27: G = __loaded[26];
+        let __v_28: G = __loaded[27];
+        let __v_29: G = __loaded[28];
+        let __v_30: G = __loaded[29];
+        let __v_31: G = __loaded[30];
+        let __v_32: G = __loaded[31];
+        let __v_33: G = __loaded[32];
+        let __v_34: G = __loaded[33];
+        let __v_35: G = __loaded[34];
+        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_35]; 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_36: G = __r_arr[0];
+        let __v_37: G = __r_arr[1];
+        let __v_38: G = __r_arr[2];
+        let __v_39: G = __r_arr[3];
+        let __v_40: G = __r_arr[4];
+        let __v_41: G = __r_arr[5];
+        let __v_42: G = __r_arr[6];
+        let __v_43: G = __r_arr[7];
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __v_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __v_46: G = __r_arr[2];
+        let __v_47: G = __r_arr[3];
+        let __v_48: G = __r_arr[4];
+        let __v_49: G = __r_arr[5];
+        let __v_50: G = __r_arr[6];
+        let __v_51: G = __r_arr[7];
+        let __ret: [G; OUT_726] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_727: usize = 1;
-const IN_727: usize = 1;
+const INPUT_SIZE_727: usize = 2;
+const IN_727: usize = 2;
 const OUT_727: usize = 1;
 fn aiur_fn_727(
   inp: [G; IN_727],
@@ -61536,43 +60342,35 @@ fn aiur_fn_727(
 ) -> Result<[G; OUT_727], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_727] = [__v_11];
-        record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
+    match __v_2.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = (__v_11 + __v_12);
-        let __ret: [G; OUT_727] = [__v_13];
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(1);
+        if (__v_3 != __v_4) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_727] = [__v_3];
         record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __ret: [G; OUT_727] = [__v_3];
+        record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_728: usize = 9;
-const IN_728: usize = 9;
-const OUT_728: usize = 45;
+const INPUT_SIZE_728: usize = 1;
+const IN_728: usize = 1;
+const OUT_728: usize = 1;
 fn aiur_fn_728(
   inp: [G; IN_728],
   record: &mut QueryRecord,
@@ -61581,147 +60379,39 @@ fn aiur_fn_728(
 ) -> Result<[G; OUT_728], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    let __v_12: G = __loaded[3];
-    let __v_13: G = __loaded[4];
-    let __v_14: G = __loaded[5];
-    let __v_15: G = __loaded[6];
-    let __v_16: G = __loaded[7];
-    let __v_17: G = __loaded[8];
-    let __v_18: G = __loaded[9];
-    let __v_19: G = __loaded[10];
-    let __v_20: G = __loaded[11];
-    let __v_21: G = __loaded[12];
-    let __v_22: G = __loaded[13];
-    let __v_23: G = __loaded[14];
-    let __v_24: G = __loaded[15];
-    let __v_25: G = __loaded[16];
-    let __v_26: G = __loaded[17];
-    let __v_27: G = __loaded[18];
-    let __v_28: G = __loaded[19];
-    let __v_29: G = __loaded[20];
-    let __v_30: G = __loaded[21];
-    let __v_31: G = __loaded[22];
-    let __v_32: G = __loaded[23];
-    let __v_33: G = __loaded[24];
-    let __v_34: G = __loaded[25];
-    let __v_35: G = __loaded[26];
-    let __v_36: G = __loaded[27];
-    let __v_37: G = __loaded[28];
-    let __v_38: G = __loaded[29];
-    let __v_39: G = __loaded[30];
-    let __v_40: G = __loaded[31];
-    let __v_41: G = __loaded[32];
-    let __v_42: G = __loaded[33];
-    let __v_43: G = __loaded[34];
-    let __v_44: G = __loaded[35];
-    let __v_45: G = __loaded[36];
-    let __v_46: G = __loaded[37];
-    let __v_47: G = __loaded[38];
-    let __v_48: G = __loaded[39];
-    let __v_49: G = __loaded[40];
-    let __v_50: G = __loaded[41];
-    let __v_51: G = __loaded[42];
-    let __v_52: G = __loaded[43];
-    let __v_53: G = __loaded[44];
-    let __v_54: G = __loaded[45];
-    let __v_55: G = __loaded[46];
-    match __v_9.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
-        let __v_56: G = __r_arr[0];
-        match __v_56.as_canonical_u64() {
-          1u64 => {
-            let __ret: [G; OUT_728] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
-            let __v_57: G = __r_arr[0];
-            let __v_58: G = __r_arr[1];
-            let __v_59: G = __r_arr[2];
-            let __v_60: G = __r_arr[3];
-            let __v_61: G = __r_arr[4];
-            let __v_62: G = __r_arr[5];
-            let __v_63: G = __r_arr[6];
-            let __v_64: G = __r_arr[7];
-            let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[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_65: G = __r_arr[0];
-            let __v_66: G = __r_arr[1];
-            let __v_67: G = __r_arr[2];
-            let __v_68: G = __r_arr[3];
-            let __v_69: G = __r_arr[4];
-            let __v_70: G = __r_arr[5];
-            let __v_71: G = __r_arr[6];
-            let __v_72: G = __r_arr[7];
-            let __v_73: G = __r_arr[8];
-            let __v_74: G = __r_arr[9];
-            let __v_75: G = __r_arr[10];
-            let __v_76: G = __r_arr[11];
-            let __v_77: G = __r_arr[12];
-            let __v_78: G = __r_arr[13];
-            let __v_79: G = __r_arr[14];
-            let __v_80: G = __r_arr[15];
-            let __v_81: G = __r_arr[16];
-            let __v_82: G = __r_arr[17];
-            let __v_83: G = __r_arr[18];
-            let __v_84: G = __r_arr[19];
-            let __v_85: G = __r_arr[20];
-            let __v_86: G = __r_arr[21];
-            let __v_87: G = __r_arr[22];
-            let __v_88: G = __r_arr[23];
-            let __v_89: G = __r_arr[24];
-            let __v_90: G = __r_arr[25];
-            let __v_91: G = __r_arr[26];
-            let __v_92: G = __r_arr[27];
-            let __v_93: G = __r_arr[28];
-            let __v_94: G = __r_arr[29];
-            let __v_95: G = __r_arr[30];
-            let __v_96: G = __r_arr[31];
-            let __v_97: G = __r_arr[32];
-            let __v_98: G = __r_arr[33];
-            let __v_99: G = __r_arr[34];
-            let __v_100: G = __r_arr[35];
-            let __v_101: G = __r_arr[36];
-            let __v_102: G = __r_arr[37];
-            let __v_103: G = __r_arr[38];
-            let __v_104: G = __r_arr[39];
-            let __v_105: G = __r_arr[40];
-            let __v_106: G = __r_arr[41];
-            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_728] = [__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[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_56.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_728] = [__v_1];
+        record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_9]; 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 = G::from_u64(1);
+        let __v_12: G = (__v_10 + __v_11);
+        let __ret: [G; OUT_728] = [__v_12];
+        record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_729: usize = 1;
-const IN_729: usize = 1;
-const OUT_729: usize = 8;
+const INPUT_SIZE_729: usize = 9;
+const IN_729: usize = 9;
+const OUT_729: usize = 45;
 fn aiur_fn_729(
   inp: [G; IN_729],
   record: &mut QueryRecord,
@@ -61730,93 +60420,145 @@ fn aiur_fn_729(
 ) -> Result<[G; OUT_729], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    let __v_11: G = __loaded[10];
-    let __v_12: G = __loaded[11];
-    let __v_13: G = __loaded[12];
-    let __v_14: G = __loaded[13];
-    let __v_15: G = __loaded[14];
-    let __v_16: G = __loaded[15];
-    let __v_17: G = __loaded[16];
-    let __v_18: G = __loaded[17];
-    let __v_19: G = __loaded[18];
-    let __v_20: G = __loaded[19];
-    let __v_21: G = __loaded[20];
-    let __v_22: G = __loaded[21];
-    let __v_23: G = __loaded[22];
-    let __v_24: G = __loaded[23];
-    let __v_25: G = __loaded[24];
-    let __v_26: G = __loaded[25];
-    let __v_27: G = __loaded[26];
-    let __v_28: G = __loaded[27];
-    let __v_29: G = __loaded[28];
-    let __v_30: G = __loaded[29];
-    let __v_31: G = __loaded[30];
-    let __v_32: G = __loaded[31];
-    let __v_33: G = __loaded[32];
-    let __v_34: G = __loaded[33];
-    let __v_35: G = __loaded[34];
-    let __v_36: G = __loaded[35];
-    let __v_37: G = __loaded[36];
-    let __v_38: G = __loaded[37];
-    let __v_39: G = __loaded[38];
-    let __v_40: G = __loaded[39];
-    let __v_41: G = __loaded[40];
-    let __v_42: G = __loaded[41];
-    let __v_43: G = __loaded[42];
-    let __v_44: G = __loaded[43];
-    let __v_45: G = __loaded[44];
-    let __v_46: G = __loaded[45];
-    let __v_47: G = __loaded[46];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_48: G = G::from_u64(0);
-        let __v_49: G = G::from_u64(0);
-        let __v_50: G = G::from_u64(0);
-        let __v_51: G = G::from_u64(0);
-        let __v_52: G = G::from_u64(0);
-        let __v_53: G = G::from_u64(0);
-        let __v_54: G = G::from_u64(0);
-        let __v_55: G = G::from_u64(0);
-        let __ret: [G; OUT_729] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55];
-        record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_47]; 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_48: G = __r_arr[0];
-        let __v_49: G = __r_arr[1];
-        let __v_50: G = __r_arr[2];
-        let __v_51: G = __r_arr[3];
-        let __v_52: G = __r_arr[4];
-        let __v_53: G = __r_arr[5];
-        let __v_54: G = __r_arr[6];
-        let __v_55: G = __r_arr[7];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_56: G = __r_arr[0];
-        let __v_57: G = __r_arr[1];
-        let __v_58: G = __r_arr[2];
-        let __v_59: G = __r_arr[3];
-        let __v_60: G = __r_arr[4];
-        let __v_61: G = __r_arr[5];
-        let __v_62: G = __r_arr[6];
-        let __v_63: G = __r_arr[7];
-        let __ret: [G; OUT_729] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
+        let __v_9: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_729] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9];
         record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_9: G = __loaded[0];
+        let __v_10: G = __loaded[1];
+        let __v_11: G = __loaded[2];
+        let __v_12: G = __loaded[3];
+        let __v_13: G = __loaded[4];
+        let __v_14: G = __loaded[5];
+        let __v_15: G = __loaded[6];
+        let __v_16: G = __loaded[7];
+        let __v_17: G = __loaded[8];
+        let __v_18: G = __loaded[9];
+        let __v_19: G = __loaded[10];
+        let __v_20: G = __loaded[11];
+        let __v_21: G = __loaded[12];
+        let __v_22: G = __loaded[13];
+        let __v_23: G = __loaded[14];
+        let __v_24: G = __loaded[15];
+        let __v_25: G = __loaded[16];
+        let __v_26: G = __loaded[17];
+        let __v_27: G = __loaded[18];
+        let __v_28: G = __loaded[19];
+        let __v_29: G = __loaded[20];
+        let __v_30: G = __loaded[21];
+        let __v_31: G = __loaded[22];
+        let __v_32: G = __loaded[23];
+        let __v_33: G = __loaded[24];
+        let __v_34: G = __loaded[25];
+        let __v_35: G = __loaded[26];
+        let __v_36: G = __loaded[27];
+        let __v_37: G = __loaded[28];
+        let __v_38: G = __loaded[29];
+        let __v_39: G = __loaded[30];
+        let __v_40: G = __loaded[31];
+        let __v_41: G = __loaded[32];
+        let __v_42: G = __loaded[33];
+        let __v_43: G = __loaded[34];
+        let __v_44: G = __loaded[35];
+        let __v_45: G = __loaded[36];
+        let __v_46: G = __loaded[37];
+        let __v_47: G = __loaded[38];
+        let __v_48: G = __loaded[39];
+        let __v_49: G = __loaded[40];
+        let __v_50: G = __loaded[41];
+        let __v_51: G = __loaded[42];
+        let __v_52: G = __loaded[43];
+        let __v_53: G = __loaded[44];
+        let __v_54: G = __loaded[45];
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+        let __v_55: G = __r_arr[0];
+        match __v_55.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_729] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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];
+            record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+            let __v_56: G = __r_arr[0];
+            let __v_57: G = __r_arr[1];
+            let __v_58: G = __r_arr[2];
+            let __v_59: G = __r_arr[3];
+            let __v_60: G = __r_arr[4];
+            let __v_61: G = __r_arr[5];
+            let __v_62: G = __r_arr[6];
+            let __v_63: G = __r_arr[7];
+            let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_54, __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[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_64: G = __r_arr[0];
+            let __v_65: G = __r_arr[1];
+            let __v_66: G = __r_arr[2];
+            let __v_67: G = __r_arr[3];
+            let __v_68: G = __r_arr[4];
+            let __v_69: G = __r_arr[5];
+            let __v_70: G = __r_arr[6];
+            let __v_71: G = __r_arr[7];
+            let __v_72: G = __r_arr[8];
+            let __v_73: G = __r_arr[9];
+            let __v_74: G = __r_arr[10];
+            let __v_75: G = __r_arr[11];
+            let __v_76: G = __r_arr[12];
+            let __v_77: G = __r_arr[13];
+            let __v_78: G = __r_arr[14];
+            let __v_79: G = __r_arr[15];
+            let __v_80: G = __r_arr[16];
+            let __v_81: G = __r_arr[17];
+            let __v_82: G = __r_arr[18];
+            let __v_83: G = __r_arr[19];
+            let __v_84: G = __r_arr[20];
+            let __v_85: G = __r_arr[21];
+            let __v_86: G = __r_arr[22];
+            let __v_87: G = __r_arr[23];
+            let __v_88: G = __r_arr[24];
+            let __v_89: G = __r_arr[25];
+            let __v_90: G = __r_arr[26];
+            let __v_91: G = __r_arr[27];
+            let __v_92: G = __r_arr[28];
+            let __v_93: G = __r_arr[29];
+            let __v_94: G = __r_arr[30];
+            let __v_95: G = __r_arr[31];
+            let __v_96: G = __r_arr[32];
+            let __v_97: G = __r_arr[33];
+            let __v_98: G = __r_arr[34];
+            let __v_99: G = __r_arr[35];
+            let __v_100: G = __r_arr[36];
+            let __v_101: G = __r_arr[37];
+            let __v_102: G = __r_arr[38];
+            let __v_103: G = __r_arr[39];
+            let __v_104: G = __r_arr[40];
+            let __v_105: G = __r_arr[41];
+            let __v_106: G = __r_arr[42];
+            let __v_107: G = __r_arr[43];
+            let __v_108: G = __r_arr[44];
+            let __ret: [G; OUT_729] = [__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];
+            record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64()));
+          },
+        }
       },
     }
   })
@@ -61833,71 +60575,166 @@ fn aiur_fn_730(
 ) -> Result<[G; OUT_730], 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 };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    let __v_11: G = __loaded[10];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = G::from_u64(0);
-        let __v_16: G = G::from_u64(0);
-        let __v_17: G = G::from_u64(0);
-        let __v_18: G = G::from_u64(0);
-        let __v_19: G = G::from_u64(0);
-        let __ret: [G; OUT_730] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_11]; 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_12: G = __r_arr[0];
-        let __v_13: G = __r_arr[1];
-        let __v_14: G = __r_arr[2];
-        let __v_15: G = __r_arr[3];
-        let __v_16: G = __r_arr[4];
-        let __v_17: G = __r_arr[5];
-        let __v_18: G = __r_arr[6];
-        let __v_19: G = __r_arr[7];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __v_21: G = __r_arr[1];
-        let __v_22: G = __r_arr[2];
-        let __v_23: G = __r_arr[3];
-        let __v_24: G = __r_arr[4];
-        let __v_25: G = __r_arr[5];
-        let __v_26: G = __r_arr[6];
-        let __v_27: G = __r_arr[7];
-        let __ret: [G; OUT_730] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27];
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_730] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
         record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 46] = { let __mq = record.memory_queries.get_mut(&46).ok_or(ExecError::InvalidMemorySize(46))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 46 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 46] = __args[..46].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __v_10: G = __loaded[9];
+        let __v_11: G = __loaded[10];
+        let __v_12: G = __loaded[11];
+        let __v_13: G = __loaded[12];
+        let __v_14: G = __loaded[13];
+        let __v_15: G = __loaded[14];
+        let __v_16: G = __loaded[15];
+        let __v_17: G = __loaded[16];
+        let __v_18: G = __loaded[17];
+        let __v_19: G = __loaded[18];
+        let __v_20: G = __loaded[19];
+        let __v_21: G = __loaded[20];
+        let __v_22: G = __loaded[21];
+        let __v_23: G = __loaded[22];
+        let __v_24: G = __loaded[23];
+        let __v_25: G = __loaded[24];
+        let __v_26: G = __loaded[25];
+        let __v_27: G = __loaded[26];
+        let __v_28: G = __loaded[27];
+        let __v_29: G = __loaded[28];
+        let __v_30: G = __loaded[29];
+        let __v_31: G = __loaded[30];
+        let __v_32: G = __loaded[31];
+        let __v_33: G = __loaded[32];
+        let __v_34: G = __loaded[33];
+        let __v_35: G = __loaded[34];
+        let __v_36: G = __loaded[35];
+        let __v_37: G = __loaded[36];
+        let __v_38: G = __loaded[37];
+        let __v_39: G = __loaded[38];
+        let __v_40: G = __loaded[39];
+        let __v_41: G = __loaded[40];
+        let __v_42: G = __loaded[41];
+        let __v_43: G = __loaded[42];
+        let __v_44: G = __loaded[43];
+        let __v_45: G = __loaded[44];
+        let __v_46: G = __loaded[45];
+        let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_46]; 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_47: G = __r_arr[0];
+        let __v_48: G = __r_arr[1];
+        let __v_49: G = __r_arr[2];
+        let __v_50: G = __r_arr[3];
+        let __v_51: G = __r_arr[4];
+        let __v_52: G = __r_arr[5];
+        let __v_53: G = __r_arr[6];
+        let __v_54: G = __r_arr[7];
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __v_55: G = __r_arr[0];
+        let __v_56: G = __r_arr[1];
+        let __v_57: G = __r_arr[2];
+        let __v_58: G = __r_arr[3];
+        let __v_59: G = __r_arr[4];
+        let __v_60: G = __r_arr[5];
+        let __v_61: G = __r_arr[6];
+        let __v_62: G = __r_arr[7];
+        let __ret: [G; OUT_730] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62];
+        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_731: usize = 9;
-const IN_731: usize = 9;
-const OUT_731: usize = 34;
+const INPUT_SIZE_731: usize = 1;
+const IN_731: usize = 1;
+const OUT_731: usize = 8;
 fn aiur_fn_731(
   inp: [G; IN_731],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_731], 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 __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_731] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __v_10: G = __loaded[9];
+        let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = __r_arr[1];
+        let __v_13: G = __r_arr[2];
+        let __v_14: G = __r_arr[3];
+        let __v_15: G = __r_arr[4];
+        let __v_16: G = __r_arr[5];
+        let __v_17: G = __r_arr[6];
+        let __v_18: G = __r_arr[7];
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __v_21: G = __r_arr[2];
+        let __v_22: G = __r_arr[3];
+        let __v_23: G = __r_arr[4];
+        let __v_24: G = __r_arr[5];
+        let __v_25: G = __r_arr[6];
+        let __v_26: G = __r_arr[7];
+        let __ret: [G; OUT_731] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
+        record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_732: usize = 9;
+const IN_732: usize = 9;
+const OUT_732: usize = 34;
+fn aiur_fn_732(
+  inp: [G; IN_732],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_732], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61908,151 +60745,122 @@ fn aiur_fn_731(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
-    let __v_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    let __v_12: G = __loaded[3];
-    let __v_13: G = __loaded[4];
-    let __v_14: G = __loaded[5];
-    let __v_15: G = __loaded[6];
-    let __v_16: G = __loaded[7];
-    let __v_17: G = __loaded[8];
-    let __v_18: G = __loaded[9];
-    let __v_19: G = __loaded[10];
-    let __v_20: G = __loaded[11];
-    let __v_21: G = __loaded[12];
-    let __v_22: G = __loaded[13];
-    let __v_23: G = __loaded[14];
-    let __v_24: G = __loaded[15];
-    let __v_25: G = __loaded[16];
-    let __v_26: G = __loaded[17];
-    let __v_27: G = __loaded[18];
-    let __v_28: G = __loaded[19];
-    let __v_29: G = __loaded[20];
-    let __v_30: G = __loaded[21];
-    let __v_31: G = __loaded[22];
-    let __v_32: G = __loaded[23];
-    let __v_33: G = __loaded[24];
-    let __v_34: G = __loaded[25];
-    let __v_35: G = __loaded[26];
-    let __v_36: G = __loaded[27];
-    let __v_37: G = __loaded[28];
-    let __v_38: G = __loaded[29];
-    let __v_39: G = __loaded[30];
-    let __v_40: G = __loaded[31];
-    let __v_41: G = __loaded[32];
-    let __v_42: G = __loaded[33];
-    let __v_43: G = __loaded[34];
-    let __v_44: G = __loaded[35];
-    match __v_9.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
+        let __v_9: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_732] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9];
+        record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 35] = { let __mq = record.memory_queries.get_mut(&35).ok_or(ExecError::InvalidMemorySize(35))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 35 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 35] = __args[..35].try_into().unwrap(); __arr };
+        let __v_9: G = __loaded[0];
+        let __v_10: G = __loaded[1];
+        let __v_11: G = __loaded[2];
+        let __v_12: G = __loaded[3];
+        let __v_13: G = __loaded[4];
+        let __v_14: G = __loaded[5];
+        let __v_15: G = __loaded[6];
+        let __v_16: G = __loaded[7];
+        let __v_17: G = __loaded[8];
+        let __v_18: G = __loaded[9];
+        let __v_19: G = __loaded[10];
+        let __v_20: G = __loaded[11];
+        let __v_21: G = __loaded[12];
+        let __v_22: G = __loaded[13];
+        let __v_23: G = __loaded[14];
+        let __v_24: G = __loaded[15];
+        let __v_25: G = __loaded[16];
+        let __v_26: G = __loaded[17];
+        let __v_27: G = __loaded[18];
+        let __v_28: G = __loaded[19];
+        let __v_29: G = __loaded[20];
+        let __v_30: G = __loaded[21];
+        let __v_31: G = __loaded[22];
+        let __v_32: G = __loaded[23];
+        let __v_33: G = __loaded[24];
+        let __v_34: G = __loaded[25];
+        let __v_35: G = __loaded[26];
+        let __v_36: G = __loaded[27];
+        let __v_37: G = __loaded[28];
+        let __v_38: G = __loaded[29];
+        let __v_39: G = __loaded[30];
+        let __v_40: G = __loaded[31];
+        let __v_41: G = __loaded[32];
+        let __v_42: G = __loaded[33];
+        let __v_43: G = __loaded[34];
         let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
-        let __v_45: G = __r_arr[0];
-        match __v_45.as_canonical_u64() {
+        let __v_44: G = __r_arr[0];
+        match __v_44.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_731] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __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[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_732] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42];
+            record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
-            let __v_46: G = __r_arr[0];
-            let __v_47: G = __r_arr[1];
-            let __v_48: G = __r_arr[2];
-            let __v_49: G = __r_arr[3];
-            let __v_50: G = __r_arr[4];
-            let __v_51: G = __r_arr[5];
-            let __v_52: G = __r_arr[6];
-            let __v_53: G = __r_arr[7];
-            let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__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[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_54: G = __r_arr[0];
-            let __v_55: G = __r_arr[1];
-            let __v_56: G = __r_arr[2];
-            let __v_57: G = __r_arr[3];
-            let __v_58: G = __r_arr[4];
-            let __v_59: G = __r_arr[5];
-            let __v_60: G = __r_arr[6];
-            let __v_61: G = __r_arr[7];
-            let __v_62: G = __r_arr[8];
-            let __v_63: G = __r_arr[9];
-            let __v_64: G = __r_arr[10];
-            let __v_65: G = __r_arr[11];
-            let __v_66: G = __r_arr[12];
-            let __v_67: G = __r_arr[13];
-            let __v_68: G = __r_arr[14];
-            let __v_69: G = __r_arr[15];
-            let __v_70: G = __r_arr[16];
-            let __v_71: G = __r_arr[17];
-            let __v_72: G = __r_arr[18];
-            let __v_73: G = __r_arr[19];
-            let __v_74: G = __r_arr[20];
-            let __v_75: G = __r_arr[21];
-            let __v_76: G = __r_arr[22];
-            let __v_77: G = __r_arr[23];
-            let __v_78: G = __r_arr[24];
-            let __v_79: G = __r_arr[25];
-            let __v_80: G = __r_arr[26];
-            let __v_81: G = __r_arr[27];
-            let __v_82: G = __r_arr[28];
-            let __v_83: G = __r_arr[29];
-            let __v_84: G = __r_arr[30];
-            let __v_85: G = __r_arr[31];
-            let __v_86: G = __r_arr[32];
-            let __v_87: G = __r_arr[33];
-            let __ret: [G; OUT_731] = [__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[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_45: G = __r_arr[0];
+            let __v_46: G = __r_arr[1];
+            let __v_47: G = __r_arr[2];
+            let __v_48: G = __r_arr[3];
+            let __v_49: G = __r_arr[4];
+            let __v_50: G = __r_arr[5];
+            let __v_51: G = __r_arr[6];
+            let __v_52: G = __r_arr[7];
+            let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_43, __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[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_53: G = __r_arr[0];
+            let __v_54: G = __r_arr[1];
+            let __v_55: G = __r_arr[2];
+            let __v_56: G = __r_arr[3];
+            let __v_57: G = __r_arr[4];
+            let __v_58: G = __r_arr[5];
+            let __v_59: G = __r_arr[6];
+            let __v_60: G = __r_arr[7];
+            let __v_61: G = __r_arr[8];
+            let __v_62: G = __r_arr[9];
+            let __v_63: G = __r_arr[10];
+            let __v_64: G = __r_arr[11];
+            let __v_65: G = __r_arr[12];
+            let __v_66: G = __r_arr[13];
+            let __v_67: G = __r_arr[14];
+            let __v_68: G = __r_arr[15];
+            let __v_69: G = __r_arr[16];
+            let __v_70: G = __r_arr[17];
+            let __v_71: G = __r_arr[18];
+            let __v_72: G = __r_arr[19];
+            let __v_73: G = __r_arr[20];
+            let __v_74: G = __r_arr[21];
+            let __v_75: G = __r_arr[22];
+            let __v_76: G = __r_arr[23];
+            let __v_77: G = __r_arr[24];
+            let __v_78: G = __r_arr[25];
+            let __v_79: G = __r_arr[26];
+            let __v_80: G = __r_arr[27];
+            let __v_81: G = __r_arr[28];
+            let __v_82: G = __r_arr[29];
+            let __v_83: G = __r_arr[30];
+            let __v_84: G = __r_arr[31];
+            let __v_85: G = __r_arr[32];
+            let __v_86: G = __r_arr[33];
+            let __ret: [G; OUT_732] = [__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];
+            record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_732: usize = 1;
-const IN_732: usize = 1;
-const OUT_732: usize = 1;
-fn aiur_fn_732(
-  inp: [G; IN_732],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_732], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_732] = [__v_4];
-        record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_732] = [__v_4];
-        record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_733: usize = 5;
-const IN_733: usize = 5;
+const INPUT_SIZE_733: usize = 1;
+const IN_733: usize = 1;
 const OUT_733: usize = 1;
 fn aiur_fn_733(
   inp: [G; IN_733],
@@ -62062,46 +60870,25 @@ fn aiur_fn_733(
 ) -> 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];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-    let __v_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    let __v_8: G = __loaded[3];
-    let __v_9: G = __loaded[4];
-    let __v_10: G = __loaded[5];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_733] = [__v_15];
-        record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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_12: G = __r_arr[0];
-        let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_733] = [__v_13];
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_733] = [__v_1];
         record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_733] = [__v_1];
+        record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_734: usize = 2;
-const IN_734: usize = 2;
+const INPUT_SIZE_734: usize = 1;
+const IN_734: usize = 1;
 const OUT_734: usize = 1;
 fn aiur_fn_734(
   inp: [G; IN_734],
@@ -62111,37 +60898,24 @@ fn aiur_fn_734(
 ) -> Result<[G; OUT_734], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 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_734] = [__v_4];
+        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));
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_2: G = __loaded[0];
-        let __v_3: G = __loaded[1];
-        let __v_4: G = __loaded[2];
-        match __v_2.as_canonical_u64() {
-          0u64 => {
-            let __v_5: G = G::from_u64(0);
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_4, __v_7]; 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_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_734] = [__v_9];
-            record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-          },
-        }
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        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 __v_3: G = __r_arr[0];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_3 + __v_4);
+        let __ret: [G; OUT_734] = [__v_5];
+        record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -62161,27 +60935,35 @@ fn aiur_fn_735(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_735] = [__v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_735] = [__v_2];
         record.function_queries[735].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_735] = { let __args: [G; IN_735] = [__v_0, __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 __v_4: G = __r_arr[0];
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
+        match __v_0.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_735] = [__v_7];
+            let __v_2: G = G::from_u64(0);
+            let __v_3: G = G::from_u64(1);
+            if (__v_2 != __v_3) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_735] = [__v_2];
             record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_2: G = __loaded[0];
+            let __v_3: G = __loaded[1];
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = (__v_1 - __v_4);
+            let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_3, __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 __v_6: G = __r_arr[0];
+            let __v_7: G = { let __values: [G; 2] = [__v_2, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_735] = [__v_7];
+            record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
@@ -62189,8 +60971,8 @@ fn aiur_fn_735(
   })
 }
 
-const INPUT_SIZE_736: usize = 1;
-const IN_736: usize = 1;
+const INPUT_SIZE_736: usize = 2;
+const IN_736: usize = 2;
 const OUT_736: usize = 1;
 fn aiur_fn_736(
   inp: [G; IN_736],
@@ -62200,38 +60982,46 @@ fn aiur_fn_736(
 ) -> Result<[G; OUT_736], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
+    let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_736] = [__v_6];
-        record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
       0u64 => {
-        let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_5]; 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_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_736] = [__v_8];
+        let __ret: [G; OUT_736] = [__v_0];
         record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_1 - __v_2);
+        let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_0, __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 __v_4: G = __r_arr[0];
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
+            if (__v_5 != __v_6) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_736] = [__v_5];
+            record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_5: G = __loaded[0];
+            let __v_6: G = __loaded[1];
+            let __ret: [G; OUT_736] = [__v_6];
+            record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_737: usize = 8;
-const IN_737: usize = 8;
-const OUT_737: usize = 6;
+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,
@@ -62240,38 +61030,34 @@ fn aiur_fn_737(
 ) -> Result<[G; OUT_737], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__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[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 __v_8: G = __r_arr[0];
-    let __v_9: G = __r_arr[1];
-    let __v_10: G = __r_arr[2];
-    let __v_11: G = __r_arr[3];
-    let __v_12: G = __r_arr[4];
-    let __v_13: G = __r_arr[5];
-    match __v_8.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = G::from_u64(1);
-        let __ret: [G; OUT_737] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13];
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_737] = [__v_1];
         record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_4]; 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_5: G = __r_arr[0];
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_5 + __v_6);
+        let __ret: [G; OUT_737] = [__v_7];
+        record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_738: usize = 9;
-const IN_738: usize = 9;
-const OUT_738: usize = 1;
+const INPUT_SIZE_738: usize = 7;
+const IN_738: usize = 7;
+const OUT_738: usize = 5;
 fn aiur_fn_738(
   inp: [G; IN_738],
   record: &mut QueryRecord,
@@ -62286,48 +61072,35 @@ fn aiur_fn_738(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    let __v_12: G = __loaded[3];
-    let __v_13: G = __loaded[4];
-    let __v_14: G = __loaded[5];
-    let __v_15: G = __loaded[6];
-    let __v_16: G = __loaded[7];
-    let __v_17: G = __loaded[8];
-    let __v_18: G = __loaded[9];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __v_19: G = G::from_u64(0);
-        let __v_20: G = G::from_u64(1);
-        let __v_21: G = G::from_u64(1);
-        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_23: G = { let __values: [G; 10] = [__v_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_738] = [__v_23];
-        record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 __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];
+    match __v_10.as_canonical_u64() {
       0u64 => {
-        let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__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[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_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_738] = [__v_21];
+        let __v_12: G = G::from_u64(0);
+        let __v_13: G = G::from_u64(1);
+        if (__v_12 != __v_13) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_738] = [__v_12, __v_12, __v_12, __v_12, __v_12];
         record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+        let __v_12: G = G::from_u64(1);
+        let __ret: [G; OUT_738] = [__v_12, __v_8, __v_9, __v_10, __v_11];
+        record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_739: usize = 1;
-const IN_739: usize = 1;
+const INPUT_SIZE_739: usize = 9;
+const IN_739: usize = 9;
 const OUT_739: usize = 1;
 fn aiur_fn_739(
   inp: [G; IN_739],
@@ -62337,31 +61110,39 @@ fn aiur_fn_739(
 ) -> Result<[G; OUT_739], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_739] = [__v_7];
-        record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } };
-        let __v_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_739] = [__v_9];
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = { let __values: [G; 9] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_739] = [__v_10];
         record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_9: G = __loaded[0];
+        let __v_10: G = __loaded[1];
+        let __v_11: G = __loaded[2];
+        let __v_12: G = __loaded[3];
+        let __v_13: G = __loaded[4];
+        let __v_14: G = __loaded[5];
+        let __v_15: G = __loaded[6];
+        let __v_16: G = __loaded[7];
+        let __v_17: G = __loaded[8];
+        let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_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[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } };
+        let __v_18: G = __r_arr[0];
+        let __v_19: G = { let __values: [G; 9] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_739] = [__v_19];
+        record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -62379,35 +61160,30 @@ fn aiur_fn_740(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_740] = [__v_1];
         record.function_queries[740].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_740] = { let __args: [G; IN_740] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_740] = [__v_7];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = { let __values: [G; 2] = [__v_2, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __ret: [G; OUT_740] = [__v_5];
         record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_741: usize = 8;
-const IN_741: usize = 8;
-const OUT_741: usize = 6;
+const INPUT_SIZE_741: usize = 7;
+const IN_741: usize = 7;
+const OUT_741: usize = 5;
 fn aiur_fn_741(
   inp: [G; IN_741],
   record: &mut QueryRecord,
@@ -62422,84 +61198,73 @@ fn aiur_fn_741(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_13: G = 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_741] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15];
+        let __v_9: G = { let __values: [G; 5] = [__v_8, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = { let __values: [G; 5] = [__v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_741] = [__v_7, __v_0, __v_1, __v_9, __v_11];
         record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-        let __v_8: G = __loaded[0];
-        let __v_9: G = __loaded[1];
-        let __v_10: G = __loaded[2];
-        let __v_11: G = __loaded[3];
-        let __v_12: G = __loaded[4];
-        let __v_13: G = __loaded[5];
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-        let __v_14: G = __loaded[0];
-        let __v_15: G = __loaded[1];
-        let __v_16: G = __loaded[2];
-        let __v_17: G = __loaded[3];
-        let __v_18: G = __loaded[4];
-        let __v_19: G = __loaded[5];
-        let __v_20: G = { 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() {
+      _ => {
+        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __v_16: G = __loaded[4];
+        let __v_17: G = { 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_17.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__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[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 __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_742] = { let __args: [G; IN_742] = [__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[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 __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_741] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
+            let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_1, __v_7, __v_8, __v_9, __v_10, __v_11]; 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 __v_18: G = __r_arr[0];
+            let __v_19: G = __r_arr[1];
+            let __v_20: G = __r_arr[2];
+            let __v_21: G = __r_arr[3];
+            let __v_22: G = __r_arr[4];
+            let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_2, __v_3, __v_4, __v_18, __v_19, __v_20, __v_21, __v_22, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 __v_23: G = __r_arr[0];
+            let __v_24: G = __r_arr[1];
+            let __v_25: G = __r_arr[2];
+            let __v_26: G = __r_arr[3];
+            let __v_27: G = __r_arr[4];
+            let __ret: [G; OUT_741] = [__v_23, __v_24, __v_25, __v_26, __v_27];
             record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_21: G = (__v_0 - __v_4);
-            match __v_21.as_canonical_u64() {
+            let __v_18: G = (__v_0 - __v_3);
+            match __v_18.as_canonical_u64() {
               0u64 => {
-                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_741] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24];
+                let __v_19: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_20: G = { let __values: [G; 5] = [__v_12, __v_13, __v_14, __v_15, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_741] = [__v_2, __v_0, __v_1, __v_19, __v_20];
                 record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__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[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 __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_742] = { let __args: [G; IN_742] = [__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[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 __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_741] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
+                let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_0, __v_1, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 __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 __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_2, __v_3, __v_4, __v_7, __v_8, __v_9, __v_10, __v_11, __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 __v_24: G = __r_arr[0];
+                let __v_25: G = __r_arr[1];
+                let __v_26: G = __r_arr[2];
+                let __v_27: G = __r_arr[3];
+                let __v_28: G = __r_arr[4];
+                let __ret: [G; OUT_741] = [__v_24, __v_25, __v_26, __v_27, __v_28];
                 record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -62507,16 +61272,13 @@ fn aiur_fn_741(
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_742: usize = 15;
-const IN_742: usize = 15;
-const OUT_742: usize = 6;
+const INPUT_SIZE_742: usize = 13;
+const IN_742: usize = 13;
+const OUT_742: usize = 5;
 fn aiur_fn_742(
   inp: [G; IN_742],
   record: &mut QueryRecord,
@@ -62537,26 +61299,22 @@ fn aiur_fn_742(
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_1, __v_2, __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[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
-        let __v_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_742] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
+        let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__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[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
+        let __v_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 __ret: [G; OUT_742] = [__v_13, __v_14, __v_15, __v_16, __v_17];
         record.function_queries[742].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_742] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17];
+        let __v_13: G = { let __values: [G; 5] = [__v_3, __v_4, __v_5, __v_6, __v_7]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_14: G = { let __values: [G; 5] = [__v_8, __v_9, __v_10, __v_11, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_742] = [__v_0, __v_1, __v_2, __v_13, __v_14];
         record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -62564,9 +61322,9 @@ fn aiur_fn_742(
   })
 }
 
-const INPUT_SIZE_743: usize = 14;
-const IN_743: usize = 14;
-const OUT_743: usize = 6;
+const INPUT_SIZE_743: usize = 12;
+const IN_743: usize = 12;
+const OUT_743: usize = 5;
 fn aiur_fn_743(
   inp: [G; IN_743],
   record: &mut QueryRecord,
@@ -62586,205 +61344,115 @@ fn aiur_fn_743(
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    match __v_2.as_canonical_u64() {
+    match __v_5.as_canonical_u64() {
       0u64 => {
-        match __v_3.as_canonical_u64() {
+        match __v_10.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-            let __v_14: G = __loaded[0];
-            let __v_15: G = __loaded[1];
-            let __v_16: G = __loaded[2];
-            let __v_17: G = __loaded[3];
-            let __v_18: G = __loaded[4];
-            let __v_19: G = __loaded[5];
-            match __v_14.as_canonical_u64() {
+            let __v_12: G = G::from_u64(1);
+            let __v_13: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_14: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_743] = [__v_12, __v_0, __v_1, __v_13, __v_14];
+            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            match __v_7.as_canonical_u64() {
               0u64 => {
+                let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_12: G = __loaded[0];
+                let __v_13: G = __loaded[1];
+                let __v_14: G = __loaded[2];
+                let __v_15: G = __loaded[3];
+                let __v_16: G = __loaded[4];
                 match __v_15.as_canonical_u64() {
                   0u64 => {
-                    let __v_20: G = G::from_u64(0);
-                    let __v_21: G = G::from_u64(0);
-                    let __v_22: G = G::from_u64(0);
-                    let __v_23: G = G::from_u64(1);
-                    let __v_24: G = { let __values: [G; 6] = [__v_22, __v_23, __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 __v_25: G = G::from_u64(0);
-                    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_743] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28];
-                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
+                    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_17: G = __loaded[0];
+                    let __v_18: G = __loaded[1];
+                    let __v_19: G = __loaded[2];
+                    let __v_20: G = __loaded[3];
+                    let __v_21: G = __loaded[4];
+                    match __v_20.as_canonical_u64() {
+                      0u64 => {
+                        let __v_22: G = G::from_u64(1);
+                        let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
+                        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        match __v_17.as_canonical_u64() {
+                          0u64 => {
+                            let __v_22: G = G::from_u64(0);
+                            let __v_23: G = G::from_u64(1);
+                            let __v_24: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_25: G = { let __values: [G; 5] = [__v_23, __v_0, __v_1, __v_24, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_26: G = G::from_u64(1);
+                            let __v_27: G = { let __values: [G; 5] = [__v_26, __v_18, __v_19, __v_20, __v_21]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __ret: [G; OUT_743] = [__v_22, __v_8, __v_9, __v_25, __v_27];
+                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __v_22: G = G::from_u64(1);
+                            let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
+                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                    }
                   },
                   _ => {
-                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                    let __v_20: G = __loaded[0];
-                    let __v_21: G = __loaded[1];
-                    let __v_22: G = __loaded[2];
-                    let __v_23: G = __loaded[3];
-                    let __v_24: G = __loaded[4];
-                    let __v_25: G = __loaded[5];
-                    match __v_20.as_canonical_u64() {
+                    match __v_12.as_canonical_u64() {
                       0u64 => {
-                        match __v_21.as_canonical_u64() {
+                        let __v_17: G = G::from_u64(0);
+                        let __v_18: G = G::from_u64(1);
+                        let __v_19: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_20: G = { let __values: [G; 5] = [__v_18, __v_0, __v_1, __v_19, __v_15]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_21: G = G::from_u64(1);
+                        let __v_22: G = { let __values: [G; 5] = [__v_21, __v_8, __v_9, __v_16, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __ret: [G; OUT_743] = [__v_17, __v_13, __v_14, __v_20, __v_22];
+                        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_17: G = __loaded[0];
+                        let __v_18: G = __loaded[1];
+                        let __v_19: G = __loaded[2];
+                        let __v_20: G = __loaded[3];
+                        let __v_21: G = __loaded[4];
+                        match __v_20.as_canonical_u64() {
                           0u64 => {
-                            let __v_26: G = G::from_u64(0);
-                            let __v_27: G = G::from_u64(0);
-                            let __v_28: G = G::from_u64(0);
-                            let __v_29: G = G::from_u64(1);
-                            let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __v_31: G = G::from_u64(0);
-                            let __v_32: G = 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_743] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
+                            let __v_22: G = G::from_u64(1);
+                            let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
                             record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
-                            match __v_8.as_canonical_u64() {
+                            match __v_17.as_canonical_u64() {
                               0u64 => {
-                                match __v_9.as_canonical_u64() {
-                                  0u64 => {
-                                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                                    let __v_26: G = __loaded[0];
-                                    let __v_27: G = __loaded[1];
-                                    let __v_28: G = __loaded[2];
-                                    let __v_29: G = __loaded[3];
-                                    let __v_30: G = __loaded[4];
-                                    let __v_31: G = __loaded[5];
-                                    match __v_26.as_canonical_u64() {
-                                      0u64 => {
-                                        match __v_27.as_canonical_u64() {
-                                          0u64 => {
-                                            let __v_32: G = G::from_u64(0);
-                                            let __v_33: G = G::from_u64(0);
-                                            let __v_34: G = G::from_u64(0);
-                                            let __v_35: G = G::from_u64(1);
-                                            let __v_36: 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_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 __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_743] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                            return Ok(__ret);
-                                          },
-                                          _ => {
-                                            let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                                            let __v_32: G = __loaded[0];
-                                            let __v_33: G = __loaded[1];
-                                            let __v_34: G = __loaded[2];
-                                            let __v_35: G = __loaded[3];
-                                            let __v_36: G = __loaded[4];
-                                            let __v_37: G = __loaded[5];
-                                            match __v_32.as_canonical_u64() {
-                                              0u64 => {
-                                                match __v_33.as_canonical_u64() {
-                                                  0u64 => {
-                                                    let __v_38: G = G::from_u64(0);
-                                                    let __v_39: G = G::from_u64(0);
-                                                    let __v_40: G = G::from_u64(0);
-                                                    let __v_41: G = G::from_u64(1);
-                                                    let __v_42: 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_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __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 __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_743] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                    return Ok(__ret);
-                                                  },
-                                                  _ => {
-                                                    let __v_38: G = G::from_u64(0);
-                                                    let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                    return Ok(__ret);
-                                                  },
-                                                }
-                                              },
-                                              _ => {
-                                                let __v_38: G = G::from_u64(0);
-                                                let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                return Ok(__ret);
-                                              },
-                                            }
-                                          },
-                                        }
-                                      },
-                                      _ => {
-                                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                                        let __v_32: G = __loaded[0];
-                                        let __v_33: G = __loaded[1];
-                                        let __v_34: G = __loaded[2];
-                                        let __v_35: G = __loaded[3];
-                                        let __v_36: G = __loaded[4];
-                                        let __v_37: G = __loaded[5];
-                                        match __v_32.as_canonical_u64() {
-                                          0u64 => {
-                                            match __v_33.as_canonical_u64() {
-                                              0u64 => {
-                                                let __v_38: G = G::from_u64(0);
-                                                let __v_39: G = G::from_u64(0);
-                                                let __v_40: G = G::from_u64(0);
-                                                let __v_41: G = G::from_u64(1);
-                                                let __v_42: 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_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __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 __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_743] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                return Ok(__ret);
-                                              },
-                                              _ => {
-                                                let __v_38: G = G::from_u64(0);
-                                                let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                return Ok(__ret);
-                                              },
-                                            }
-                                          },
-                                          _ => {
-                                            let __v_38: G = G::from_u64(0);
-                                            let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                            return Ok(__ret);
-                                          },
-                                        }
-                                      },
-                                    }
-                                  },
-                                  _ => {
-                                    let __v_26: G = G::from_u64(0);
-                                    let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                    return Ok(__ret);
-                                  },
-                                }
+                                let __v_22: G = G::from_u64(0);
+                                let __v_23: G = G::from_u64(1);
+                                let __v_24: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_25: G = { let __values: [G; 5] = [__v_23, __v_0, __v_1, __v_24, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_26: G = G::from_u64(1);
+                                let __v_27: G = { let __values: [G; 5] = [__v_26, __v_18, __v_19, __v_20, __v_21]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __ret: [G; OUT_743] = [__v_22, __v_8, __v_9, __v_25, __v_27];
+                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
                               },
                               _ => {
-                                let __v_26: G = G::from_u64(0);
-                                let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                let __v_22: G = G::from_u64(1);
+                                let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
                                 record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
@@ -62792,150 +61460,164 @@ fn aiur_fn_743(
                           },
                         }
                       },
+                    }
+                  },
+                }
+              },
+              _ => {
+                let __v_12: G = G::from_u64(1);
+                let __v_13: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_14: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_743] = [__v_12, __v_0, __v_1, __v_13, __v_14];
+                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_12: G = __loaded[0];
+            let __v_13: G = __loaded[1];
+            let __v_14: G = __loaded[2];
+            let __v_15: G = __loaded[3];
+            let __v_16: G = __loaded[4];
+            match __v_15.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_17: G = __loaded[0];
+                let __v_18: G = __loaded[1];
+                let __v_19: G = __loaded[2];
+                let __v_20: G = __loaded[3];
+                let __v_21: G = __loaded[4];
+                match __v_20.as_canonical_u64() {
+                  0u64 => {
+                    match __v_10.as_canonical_u64() {
+                      0u64 => {
+                        let __v_22: G = G::from_u64(1);
+                        let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
+                        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
                       _ => {
-                        match __v_8.as_canonical_u64() {
+                        match __v_7.as_canonical_u64() {
                           0u64 => {
-                            match __v_9.as_canonical_u64() {
+                            let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_22: G = __loaded[0];
+                            let __v_23: G = __loaded[1];
+                            let __v_24: G = __loaded[2];
+                            let __v_25: G = __loaded[3];
+                            let __v_26: G = __loaded[4];
+                            match __v_25.as_canonical_u64() {
                               0u64 => {
-                                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                                let __v_26: G = __loaded[0];
-                                let __v_27: G = __loaded[1];
-                                let __v_28: G = __loaded[2];
-                                let __v_29: G = __loaded[3];
-                                let __v_30: G = __loaded[4];
-                                let __v_31: G = __loaded[5];
-                                match __v_26.as_canonical_u64() {
+                                let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_27: G = __loaded[0];
+                                let __v_28: G = __loaded[1];
+                                let __v_29: G = __loaded[2];
+                                let __v_30: G = __loaded[3];
+                                let __v_31: G = __loaded[4];
+                                match __v_30.as_canonical_u64() {
                                   0u64 => {
+                                    let __v_32: G = G::from_u64(1);
+                                    let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
+                                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
                                     match __v_27.as_canonical_u64() {
                                       0u64 => {
                                         let __v_32: G = G::from_u64(0);
-                                        let __v_33: G = G::from_u64(0);
-                                        let __v_34: G = G::from_u64(0);
-                                        let __v_35: G = G::from_u64(1);
-                                        let __v_36: 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_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 __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_743] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                        let __v_33: G = G::from_u64(1);
+                                        let __v_34: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __v_35: G = { let __values: [G; 5] = [__v_33, __v_0, __v_1, __v_34, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __v_36: G = G::from_u64(1);
+                                        let __v_37: G = { let __values: [G; 5] = [__v_36, __v_28, __v_29, __v_30, __v_31]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __ret: [G; OUT_743] = [__v_32, __v_8, __v_9, __v_35, __v_37];
                                         record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                                        let __v_32: G = __loaded[0];
-                                        let __v_33: G = __loaded[1];
-                                        let __v_34: G = __loaded[2];
-                                        let __v_35: G = __loaded[3];
-                                        let __v_36: G = __loaded[4];
-                                        let __v_37: G = __loaded[5];
-                                        match __v_32.as_canonical_u64() {
-                                          0u64 => {
-                                            match __v_33.as_canonical_u64() {
-                                              0u64 => {
-                                                let __v_38: G = G::from_u64(0);
-                                                let __v_39: G = G::from_u64(0);
-                                                let __v_40: G = G::from_u64(0);
-                                                let __v_41: G = G::from_u64(1);
-                                                let __v_42: 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_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __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 __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_743] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                return Ok(__ret);
-                                              },
-                                              _ => {
-                                                let __v_38: G = G::from_u64(0);
-                                                let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                return Ok(__ret);
-                                              },
-                                            }
-                                          },
-                                          _ => {
-                                            let __v_38: G = G::from_u64(0);
-                                            let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                            return Ok(__ret);
-                                          },
-                                        }
+                                        let __v_32: G = G::from_u64(1);
+                                        let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
+                                        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
                                       },
                                     }
                                   },
+                                }
+                              },
+                              _ => {
+                                match __v_22.as_canonical_u64() {
+                                  0u64 => {
+                                    let __v_27: G = G::from_u64(0);
+                                    let __v_28: G = G::from_u64(1);
+                                    let __v_29: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_30: G = { let __values: [G; 5] = [__v_28, __v_0, __v_1, __v_29, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_31: G = G::from_u64(1);
+                                    let __v_32: G = { let __values: [G; 5] = [__v_31, __v_8, __v_9, __v_26, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __ret: [G; OUT_743] = [__v_27, __v_23, __v_24, __v_30, __v_32];
+                                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
                                   _ => {
-                                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                                    let __v_32: G = __loaded[0];
-                                    let __v_33: G = __loaded[1];
-                                    let __v_34: G = __loaded[2];
-                                    let __v_35: G = __loaded[3];
-                                    let __v_36: G = __loaded[4];
-                                    let __v_37: G = __loaded[5];
-                                    match __v_32.as_canonical_u64() {
+                                    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_27: G = __loaded[0];
+                                    let __v_28: G = __loaded[1];
+                                    let __v_29: G = __loaded[2];
+                                    let __v_30: G = __loaded[3];
+                                    let __v_31: G = __loaded[4];
+                                    match __v_30.as_canonical_u64() {
                                       0u64 => {
-                                        match __v_33.as_canonical_u64() {
+                                        let __v_32: G = G::from_u64(1);
+                                        let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
+                                        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        match __v_27.as_canonical_u64() {
                                           0u64 => {
-                                            let __v_38: G = G::from_u64(0);
-                                            let __v_39: G = G::from_u64(0);
-                                            let __v_40: G = G::from_u64(0);
-                                            let __v_41: G = G::from_u64(1);
-                                            let __v_42: 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_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __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 __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_743] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            let __v_32: G = G::from_u64(0);
+                                            let __v_33: G = G::from_u64(1);
+                                            let __v_34: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_35: G = { let __values: [G; 5] = [__v_33, __v_0, __v_1, __v_34, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_36: G = G::from_u64(1);
+                                            let __v_37: G = { let __values: [G; 5] = [__v_36, __v_28, __v_29, __v_30, __v_31]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __ret: [G; OUT_743] = [__v_32, __v_8, __v_9, __v_35, __v_37];
                                             record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __v_38: G = G::from_u64(0);
-                                            let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            let __v_32: G = G::from_u64(1);
+                                            let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
                                             record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
                                       },
-                                      _ => {
-                                        let __v_38: G = G::from_u64(0);
-                                        let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                        return Ok(__ret);
-                                      },
                                     }
                                   },
                                 }
                               },
-                              _ => {
-                                let __v_26: G = G::from_u64(0);
-                                let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
                             }
                           },
                           _ => {
-                            let __v_26: G = G::from_u64(0);
-                            let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            let __v_22: G = G::from_u64(1);
+                            let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
                             record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
@@ -62943,104 +61625,73 @@ fn aiur_fn_743(
                       },
                     }
                   },
-                }
-              },
-              _ => {
-                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                let __v_20: G = __loaded[0];
-                let __v_21: G = __loaded[1];
-                let __v_22: G = __loaded[2];
-                let __v_23: G = __loaded[3];
-                let __v_24: G = __loaded[4];
-                let __v_25: G = __loaded[5];
-                match __v_20.as_canonical_u64() {
-                  0u64 => {
-                    match __v_21.as_canonical_u64() {
+                  _ => {
+                    match __v_17.as_canonical_u64() {
                       0u64 => {
-                        let __v_26: G = G::from_u64(0);
-                        let __v_27: G = G::from_u64(0);
-                        let __v_28: G = G::from_u64(0);
-                        let __v_29: G = G::from_u64(1);
-                        let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_31: G = G::from_u64(0);
-                        let __v_32: G = 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_743] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
+                        let __v_22: G = G::from_u64(0);
+                        let __v_23: G = G::from_u64(1);
+                        let __v_24: G = { let __values: [G; 5] = [__v_23, __v_3, __v_4, __v_5, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_25: G = G::from_u64(1);
+                        let __v_26: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_27: G = { let __values: [G; 5] = [__v_25, __v_0, __v_1, __v_21, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __ret: [G; OUT_743] = [__v_22, __v_18, __v_19, __v_24, __v_27];
                         record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
-                        match __v_8.as_canonical_u64() {
+                        match __v_10.as_canonical_u64() {
                           0u64 => {
-                            match __v_9.as_canonical_u64() {
+                            let __v_22: G = G::from_u64(1);
+                            let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
+                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            match __v_7.as_canonical_u64() {
                               0u64 => {
-                                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                                let __v_26: G = __loaded[0];
-                                let __v_27: G = __loaded[1];
-                                let __v_28: G = __loaded[2];
-                                let __v_29: G = __loaded[3];
-                                let __v_30: G = __loaded[4];
-                                let __v_31: G = __loaded[5];
-                                match __v_26.as_canonical_u64() {
+                                let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_22: G = __loaded[0];
+                                let __v_23: G = __loaded[1];
+                                let __v_24: G = __loaded[2];
+                                let __v_25: G = __loaded[3];
+                                let __v_26: G = __loaded[4];
+                                match __v_25.as_canonical_u64() {
                                   0u64 => {
-                                    match __v_27.as_canonical_u64() {
+                                    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_27: G = __loaded[0];
+                                    let __v_28: G = __loaded[1];
+                                    let __v_29: G = __loaded[2];
+                                    let __v_30: G = __loaded[3];
+                                    let __v_31: G = __loaded[4];
+                                    match __v_30.as_canonical_u64() {
                                       0u64 => {
-                                        let __v_32: G = G::from_u64(0);
-                                        let __v_33: G = G::from_u64(0);
-                                        let __v_34: G = G::from_u64(0);
-                                        let __v_35: G = G::from_u64(1);
-                                        let __v_36: 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_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 __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_743] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                        let __v_32: G = G::from_u64(1);
+                                        let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
                                         record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                                        let __v_32: G = __loaded[0];
-                                        let __v_33: G = __loaded[1];
-                                        let __v_34: G = __loaded[2];
-                                        let __v_35: G = __loaded[3];
-                                        let __v_36: G = __loaded[4];
-                                        let __v_37: G = __loaded[5];
-                                        match __v_32.as_canonical_u64() {
+                                        match __v_27.as_canonical_u64() {
                                           0u64 => {
-                                            match __v_33.as_canonical_u64() {
-                                              0u64 => {
-                                                let __v_38: G = G::from_u64(0);
-                                                let __v_39: G = G::from_u64(0);
-                                                let __v_40: G = G::from_u64(0);
-                                                let __v_41: G = G::from_u64(1);
-                                                let __v_42: 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_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __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 __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_743] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                return Ok(__ret);
-                                              },
-                                              _ => {
-                                                let __v_38: G = G::from_u64(0);
-                                                let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                return Ok(__ret);
-                                              },
-                                            }
+                                            let __v_32: G = G::from_u64(0);
+                                            let __v_33: G = G::from_u64(1);
+                                            let __v_34: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_35: G = { let __values: [G; 5] = [__v_33, __v_0, __v_1, __v_34, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_36: G = G::from_u64(1);
+                                            let __v_37: G = { let __values: [G; 5] = [__v_36, __v_28, __v_29, __v_30, __v_31]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __ret: [G; OUT_743] = [__v_32, __v_8, __v_9, __v_35, __v_37];
+                                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            return Ok(__ret);
                                           },
                                           _ => {
-                                            let __v_38: G = G::from_u64(0);
-                                            let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            let __v_32: G = G::from_u64(1);
+                                            let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
                                             record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
@@ -63049,529 +61700,514 @@ fn aiur_fn_743(
                                     }
                                   },
                                   _ => {
-                                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                                    let __v_32: G = __loaded[0];
-                                    let __v_33: G = __loaded[1];
-                                    let __v_34: G = __loaded[2];
-                                    let __v_35: G = __loaded[3];
-                                    let __v_36: G = __loaded[4];
-                                    let __v_37: G = __loaded[5];
-                                    match __v_32.as_canonical_u64() {
+                                    match __v_22.as_canonical_u64() {
                                       0u64 => {
-                                        match __v_33.as_canonical_u64() {
+                                        let __v_27: G = G::from_u64(0);
+                                        let __v_28: G = G::from_u64(1);
+                                        let __v_29: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __v_30: G = { let __values: [G; 5] = [__v_28, __v_0, __v_1, __v_29, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __v_31: G = G::from_u64(1);
+                                        let __v_32: G = { let __values: [G; 5] = [__v_31, __v_8, __v_9, __v_26, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __ret: [G; OUT_743] = [__v_27, __v_23, __v_24, __v_30, __v_32];
+                                        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_27: G = __loaded[0];
+                                        let __v_28: G = __loaded[1];
+                                        let __v_29: G = __loaded[2];
+                                        let __v_30: G = __loaded[3];
+                                        let __v_31: G = __loaded[4];
+                                        match __v_30.as_canonical_u64() {
                                           0u64 => {
-                                            let __v_38: G = G::from_u64(0);
-                                            let __v_39: G = G::from_u64(0);
-                                            let __v_40: G = G::from_u64(0);
-                                            let __v_41: G = G::from_u64(1);
-                                            let __v_42: 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_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __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 __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_743] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            let __v_32: G = G::from_u64(1);
+                                            let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
                                             record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __v_38: G = G::from_u64(0);
-                                            let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                            return Ok(__ret);
+                                            match __v_27.as_canonical_u64() {
+                                              0u64 => {
+                                                let __v_32: G = G::from_u64(0);
+                                                let __v_33: G = G::from_u64(1);
+                                                let __v_34: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __v_35: G = { let __values: [G; 5] = [__v_33, __v_0, __v_1, __v_34, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __v_36: G = G::from_u64(1);
+                                                let __v_37: G = { let __values: [G; 5] = [__v_36, __v_28, __v_29, __v_30, __v_31]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __ret: [G; OUT_743] = [__v_32, __v_8, __v_9, __v_35, __v_37];
+                                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                return Ok(__ret);
+                                              },
+                                              _ => {
+                                                let __v_32: G = G::from_u64(1);
+                                                let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
+                                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                return Ok(__ret);
+                                              },
+                                            }
                                           },
                                         }
                                       },
-                                      _ => {
-                                        let __v_38: G = G::from_u64(0);
-                                        let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                        return Ok(__ret);
-                                      },
                                     }
                                   },
                                 }
                               },
                               _ => {
-                                let __v_26: G = G::from_u64(0);
-                                let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                let __v_22: G = G::from_u64(1);
+                                let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
                                 record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
                           },
-                          _ => {
-                            let __v_26: G = G::from_u64(0);
-                            let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
                         }
                       },
                     }
                   },
+                }
+              },
+              _ => {
+                match __v_12.as_canonical_u64() {
+                  0u64 => {
+                    let __v_17: G = G::from_u64(0);
+                    let __v_18: G = G::from_u64(1);
+                    let __v_19: G = { let __values: [G; 5] = [__v_18, __v_13, __v_14, __v_15, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_20: G = G::from_u64(1);
+                    let __v_21: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_22: G = { let __values: [G; 5] = [__v_20, __v_0, __v_1, __v_6, __v_21]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __ret: [G; OUT_743] = [__v_17, __v_3, __v_4, __v_19, __v_22];
+                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
                   _ => {
-                    match __v_8.as_canonical_u64() {
+                    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_17: G = __loaded[0];
+                    let __v_18: G = __loaded[1];
+                    let __v_19: G = __loaded[2];
+                    let __v_20: G = __loaded[3];
+                    let __v_21: G = __loaded[4];
+                    match __v_20.as_canonical_u64() {
                       0u64 => {
-                        match __v_9.as_canonical_u64() {
+                        match __v_10.as_canonical_u64() {
                           0u64 => {
-                            let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                            let __v_26: G = __loaded[0];
-                            let __v_27: G = __loaded[1];
-                            let __v_28: G = __loaded[2];
-                            let __v_29: G = __loaded[3];
-                            let __v_30: G = __loaded[4];
-                            let __v_31: G = __loaded[5];
-                            match __v_26.as_canonical_u64() {
+                            let __v_22: G = G::from_u64(1);
+                            let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
+                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            match __v_7.as_canonical_u64() {
                               0u64 => {
-                                match __v_27.as_canonical_u64() {
+                                let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_22: G = __loaded[0];
+                                let __v_23: G = __loaded[1];
+                                let __v_24: G = __loaded[2];
+                                let __v_25: G = __loaded[3];
+                                let __v_26: G = __loaded[4];
+                                match __v_25.as_canonical_u64() {
                                   0u64 => {
-                                    let __v_32: G = G::from_u64(0);
-                                    let __v_33: G = G::from_u64(0);
-                                    let __v_34: G = G::from_u64(0);
-                                    let __v_35: G = G::from_u64(1);
-                                    let __v_36: 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_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 __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_743] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                    return Ok(__ret);
-                                  },
-                                  _ => {
-                                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                                    let __v_32: G = __loaded[0];
-                                    let __v_33: G = __loaded[1];
-                                    let __v_34: G = __loaded[2];
-                                    let __v_35: G = __loaded[3];
-                                    let __v_36: G = __loaded[4];
-                                    let __v_37: G = __loaded[5];
-                                    match __v_32.as_canonical_u64() {
+                                    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_27: G = __loaded[0];
+                                    let __v_28: G = __loaded[1];
+                                    let __v_29: G = __loaded[2];
+                                    let __v_30: G = __loaded[3];
+                                    let __v_31: G = __loaded[4];
+                                    match __v_30.as_canonical_u64() {
                                       0u64 => {
-                                        match __v_33.as_canonical_u64() {
+                                        let __v_32: G = G::from_u64(1);
+                                        let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
+                                        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        match __v_27.as_canonical_u64() {
                                           0u64 => {
-                                            let __v_38: G = G::from_u64(0);
-                                            let __v_39: G = G::from_u64(0);
-                                            let __v_40: G = G::from_u64(0);
-                                            let __v_41: G = G::from_u64(1);
-                                            let __v_42: 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_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __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 __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_743] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            let __v_32: G = G::from_u64(0);
+                                            let __v_33: G = G::from_u64(1);
+                                            let __v_34: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_35: G = { let __values: [G; 5] = [__v_33, __v_0, __v_1, __v_34, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_36: G = G::from_u64(1);
+                                            let __v_37: G = { let __values: [G; 5] = [__v_36, __v_28, __v_29, __v_30, __v_31]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __ret: [G; OUT_743] = [__v_32, __v_8, __v_9, __v_35, __v_37];
                                             record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __v_38: G = G::from_u64(0);
-                                            let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            let __v_32: G = G::from_u64(1);
+                                            let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
                                             record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
                                       },
-                                      _ => {
-                                        let __v_38: G = G::from_u64(0);
-                                        let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                        return Ok(__ret);
-                                      },
                                     }
                                   },
-                                }
-                              },
-                              _ => {
-                                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                                let __v_32: G = __loaded[0];
-                                let __v_33: G = __loaded[1];
-                                let __v_34: G = __loaded[2];
-                                let __v_35: G = __loaded[3];
-                                let __v_36: G = __loaded[4];
-                                let __v_37: G = __loaded[5];
-                                match __v_32.as_canonical_u64() {
-                                  0u64 => {
-                                    match __v_33.as_canonical_u64() {
+                                  _ => {
+                                    match __v_22.as_canonical_u64() {
                                       0u64 => {
-                                        let __v_38: G = G::from_u64(0);
-                                        let __v_39: G = G::from_u64(0);
-                                        let __v_40: G = G::from_u64(0);
-                                        let __v_41: G = G::from_u64(1);
-                                        let __v_42: 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_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __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 __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_743] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                        let __v_27: G = G::from_u64(0);
+                                        let __v_28: G = G::from_u64(1);
+                                        let __v_29: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __v_30: G = { let __values: [G; 5] = [__v_28, __v_0, __v_1, __v_29, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __v_31: G = G::from_u64(1);
+                                        let __v_32: G = { let __values: [G; 5] = [__v_31, __v_8, __v_9, __v_26, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __ret: [G; OUT_743] = [__v_27, __v_23, __v_24, __v_30, __v_32];
                                         record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __v_38: G = G::from_u64(0);
-                                        let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                        return Ok(__ret);
+                                        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_27: G = __loaded[0];
+                                        let __v_28: G = __loaded[1];
+                                        let __v_29: G = __loaded[2];
+                                        let __v_30: G = __loaded[3];
+                                        let __v_31: G = __loaded[4];
+                                        match __v_30.as_canonical_u64() {
+                                          0u64 => {
+                                            let __v_32: G = G::from_u64(1);
+                                            let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
+                                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            return Ok(__ret);
+                                          },
+                                          _ => {
+                                            match __v_27.as_canonical_u64() {
+                                              0u64 => {
+                                                let __v_32: G = G::from_u64(0);
+                                                let __v_33: G = G::from_u64(1);
+                                                let __v_34: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __v_35: G = { let __values: [G; 5] = [__v_33, __v_0, __v_1, __v_34, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __v_36: G = G::from_u64(1);
+                                                let __v_37: G = { let __values: [G; 5] = [__v_36, __v_28, __v_29, __v_30, __v_31]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __ret: [G; OUT_743] = [__v_32, __v_8, __v_9, __v_35, __v_37];
+                                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                return Ok(__ret);
+                                              },
+                                              _ => {
+                                                let __v_32: G = G::from_u64(1);
+                                                let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
+                                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                return Ok(__ret);
+                                              },
+                                            }
+                                          },
+                                        }
                                       },
                                     }
                                   },
-                                  _ => {
-                                    let __v_38: G = G::from_u64(0);
-                                    let __v_39: G = G::from_u64(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_743] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                    return Ok(__ret);
-                                  },
                                 }
                               },
+                              _ => {
+                                let __v_22: G = G::from_u64(1);
+                                let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
+                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
                             }
                           },
-                          _ => {
-                            let __v_26: G = G::from_u64(0);
-                            let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
                         }
                       },
                       _ => {
-                        let __v_26: G = G::from_u64(0);
-                        let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                    }
-                  },
-                }
-              },
-            }
-          },
-          _ => {
-            match __v_8.as_canonical_u64() {
-              0u64 => {
-                match __v_9.as_canonical_u64() {
-                  0u64 => {
-                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                    let __v_14: G = __loaded[0];
-                    let __v_15: G = __loaded[1];
-                    let __v_16: G = __loaded[2];
-                    let __v_17: G = __loaded[3];
-                    let __v_18: G = __loaded[4];
-                    let __v_19: G = __loaded[5];
-                    match __v_14.as_canonical_u64() {
-                      0u64 => {
-                        match __v_15.as_canonical_u64() {
+                        match __v_17.as_canonical_u64() {
                           0u64 => {
-                            let __v_20: G = G::from_u64(0);
-                            let __v_21: G = G::from_u64(0);
                             let __v_22: G = G::from_u64(0);
                             let __v_23: G = G::from_u64(1);
-                            let __v_24: 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_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __v_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_743] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
+                            let __v_24: G = { let __values: [G; 5] = [__v_23, __v_3, __v_4, __v_5, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_25: G = G::from_u64(1);
+                            let __v_26: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_27: G = { let __values: [G; 5] = [__v_25, __v_0, __v_1, __v_21, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __ret: [G; OUT_743] = [__v_22, __v_18, __v_19, __v_24, __v_27];
                             record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
-                            let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                            let __v_20: G = __loaded[0];
-                            let __v_21: G = __loaded[1];
-                            let __v_22: G = __loaded[2];
-                            let __v_23: G = __loaded[3];
-                            let __v_24: G = __loaded[4];
-                            let __v_25: G = __loaded[5];
-                            match __v_20.as_canonical_u64() {
+                            match __v_10.as_canonical_u64() {
                               0u64 => {
-                                match __v_21.as_canonical_u64() {
+                                let __v_22: G = G::from_u64(1);
+                                let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
+                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                match __v_7.as_canonical_u64() {
                                   0u64 => {
-                                    let __v_26: G = G::from_u64(0);
-                                    let __v_27: G = G::from_u64(0);
-                                    let __v_28: G = G::from_u64(0);
-                                    let __v_29: G = G::from_u64(1);
-                                    let __v_30: 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_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __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 __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_743] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                    return Ok(__ret);
+                                    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_22: G = __loaded[0];
+                                    let __v_23: G = __loaded[1];
+                                    let __v_24: G = __loaded[2];
+                                    let __v_25: G = __loaded[3];
+                                    let __v_26: G = __loaded[4];
+                                    match __v_25.as_canonical_u64() {
+                                      0u64 => {
+                                        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_27: G = __loaded[0];
+                                        let __v_28: G = __loaded[1];
+                                        let __v_29: G = __loaded[2];
+                                        let __v_30: G = __loaded[3];
+                                        let __v_31: G = __loaded[4];
+                                        match __v_30.as_canonical_u64() {
+                                          0u64 => {
+                                            let __v_32: G = G::from_u64(1);
+                                            let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
+                                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            return Ok(__ret);
+                                          },
+                                          _ => {
+                                            match __v_27.as_canonical_u64() {
+                                              0u64 => {
+                                                let __v_32: G = G::from_u64(0);
+                                                let __v_33: G = G::from_u64(1);
+                                                let __v_34: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __v_35: G = { let __values: [G; 5] = [__v_33, __v_0, __v_1, __v_34, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __v_36: G = G::from_u64(1);
+                                                let __v_37: G = { let __values: [G; 5] = [__v_36, __v_28, __v_29, __v_30, __v_31]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __ret: [G; OUT_743] = [__v_32, __v_8, __v_9, __v_35, __v_37];
+                                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                return Ok(__ret);
+                                              },
+                                              _ => {
+                                                let __v_32: G = G::from_u64(1);
+                                                let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
+                                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                return Ok(__ret);
+                                              },
+                                            }
+                                          },
+                                        }
+                                      },
+                                      _ => {
+                                        match __v_22.as_canonical_u64() {
+                                          0u64 => {
+                                            let __v_27: G = G::from_u64(0);
+                                            let __v_28: G = G::from_u64(1);
+                                            let __v_29: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_30: G = { let __values: [G; 5] = [__v_28, __v_0, __v_1, __v_29, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_31: G = G::from_u64(1);
+                                            let __v_32: G = { let __values: [G; 5] = [__v_31, __v_8, __v_9, __v_26, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __ret: [G; OUT_743] = [__v_27, __v_23, __v_24, __v_30, __v_32];
+                                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            return Ok(__ret);
+                                          },
+                                          _ => {
+                                            let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_27: G = __loaded[0];
+                                            let __v_28: G = __loaded[1];
+                                            let __v_29: G = __loaded[2];
+                                            let __v_30: G = __loaded[3];
+                                            let __v_31: G = __loaded[4];
+                                            match __v_30.as_canonical_u64() {
+                                              0u64 => {
+                                                let __v_32: G = G::from_u64(1);
+                                                let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
+                                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                return Ok(__ret);
+                                              },
+                                              _ => {
+                                                match __v_27.as_canonical_u64() {
+                                                  0u64 => {
+                                                    let __v_32: G = G::from_u64(0);
+                                                    let __v_33: G = G::from_u64(1);
+                                                    let __v_34: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                    let __v_35: G = { let __values: [G; 5] = [__v_33, __v_0, __v_1, __v_34, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                    let __v_36: G = G::from_u64(1);
+                                                    let __v_37: G = { let __values: [G; 5] = [__v_36, __v_28, __v_29, __v_30, __v_31]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                    let __ret: [G; OUT_743] = [__v_32, __v_8, __v_9, __v_35, __v_37];
+                                                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    return Ok(__ret);
+                                                  },
+                                                  _ => {
+                                                    let __v_32: G = G::from_u64(1);
+                                                    let __v_33: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                    let __v_34: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                    let __ret: [G; OUT_743] = [__v_32, __v_0, __v_1, __v_33, __v_34];
+                                                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    return Ok(__ret);
+                                                  },
+                                                }
+                                              },
+                                            }
+                                          },
+                                        }
+                                      },
+                                    }
                                   },
                                   _ => {
-                                    let __v_26: G = G::from_u64(0);
-                                    let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                    let __v_22: G = G::from_u64(1);
+                                    let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
                                     record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
                               },
-                              _ => {
-                                let __v_26: G = G::from_u64(0);
-                                let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                            }
-                          },
-                        }
-                      },
-                      _ => {
-                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                        let __v_20: G = __loaded[0];
-                        let __v_21: G = __loaded[1];
-                        let __v_22: G = __loaded[2];
-                        let __v_23: G = __loaded[3];
-                        let __v_24: G = __loaded[4];
-                        let __v_25: G = __loaded[5];
-                        match __v_20.as_canonical_u64() {
-                          0u64 => {
-                            match __v_21.as_canonical_u64() {
-                              0u64 => {
-                                let __v_26: G = G::from_u64(0);
-                                let __v_27: G = G::from_u64(0);
-                                let __v_28: G = G::from_u64(0);
-                                let __v_29: G = G::from_u64(1);
-                                let __v_30: 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_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __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 __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_743] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              _ => {
-                                let __v_26: G = G::from_u64(0);
-                                let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
                             }
                           },
-                          _ => {
-                            let __v_26: G = G::from_u64(0);
-                            let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
                         }
                       },
                     }
                   },
-                  _ => {
-                    let __v_14: G = G::from_u64(0);
-                    let __v_15: G = G::from_u64(1);
-                    let __v_16: G = { 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_743] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
                 }
               },
-              _ => {
-                let __v_14: G = G::from_u64(0);
-                let __v_15: G = G::from_u64(1);
-                let __v_16: G = { 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_743] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
             }
           },
-        }
-      },
-      _ => {
-        match __v_8.as_canonical_u64() {
-          0u64 => {
-            match __v_9.as_canonical_u64() {
+          _ => {
+            match __v_10.as_canonical_u64() {
               0u64 => {
-                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                let __v_14: G = __loaded[0];
-                let __v_15: G = __loaded[1];
-                let __v_16: G = __loaded[2];
-                let __v_17: G = __loaded[3];
-                let __v_18: G = __loaded[4];
-                let __v_19: G = __loaded[5];
-                match __v_14.as_canonical_u64() {
+                let __v_12: G = G::from_u64(1);
+                let __v_13: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_14: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_743] = [__v_12, __v_0, __v_1, __v_13, __v_14];
+                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                match __v_7.as_canonical_u64() {
                   0u64 => {
+                    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_12: G = __loaded[0];
+                    let __v_13: G = __loaded[1];
+                    let __v_14: G = __loaded[2];
+                    let __v_15: G = __loaded[3];
+                    let __v_16: G = __loaded[4];
                     match __v_15.as_canonical_u64() {
                       0u64 => {
-                        let __v_20: G = G::from_u64(0);
-                        let __v_21: G = G::from_u64(0);
-                        let __v_22: G = G::from_u64(0);
-                        let __v_23: G = G::from_u64(1);
-                        let __v_24: 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_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_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_743] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
-                        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                        let __v_20: G = __loaded[0];
-                        let __v_21: G = __loaded[1];
-                        let __v_22: G = __loaded[2];
-                        let __v_23: G = __loaded[3];
-                        let __v_24: G = __loaded[4];
-                        let __v_25: G = __loaded[5];
+                        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_17: G = __loaded[0];
+                        let __v_18: G = __loaded[1];
+                        let __v_19: G = __loaded[2];
+                        let __v_20: G = __loaded[3];
+                        let __v_21: G = __loaded[4];
                         match __v_20.as_canonical_u64() {
                           0u64 => {
-                            match __v_21.as_canonical_u64() {
+                            let __v_22: G = G::from_u64(1);
+                            let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
+                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            match __v_17.as_canonical_u64() {
                               0u64 => {
-                                let __v_26: G = G::from_u64(0);
-                                let __v_27: G = G::from_u64(0);
-                                let __v_28: G = G::from_u64(0);
-                                let __v_29: G = G::from_u64(1);
-                                let __v_30: 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_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __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 __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_743] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                                let __v_22: G = G::from_u64(0);
+                                let __v_23: G = G::from_u64(1);
+                                let __v_24: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_25: G = { let __values: [G; 5] = [__v_23, __v_0, __v_1, __v_24, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_26: G = G::from_u64(1);
+                                let __v_27: G = { let __values: [G; 5] = [__v_26, __v_18, __v_19, __v_20, __v_21]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __ret: [G; OUT_743] = [__v_22, __v_8, __v_9, __v_25, __v_27];
                                 record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
-                                let __v_26: G = G::from_u64(0);
-                                let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                let __v_22: G = G::from_u64(1);
+                                let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
                                 record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
                           },
-                          _ => {
-                            let __v_26: G = G::from_u64(0);
-                            let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
                         }
                       },
-                    }
-                  },
-                  _ => {
-                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-                    let __v_20: G = __loaded[0];
-                    let __v_21: G = __loaded[1];
-                    let __v_22: G = __loaded[2];
-                    let __v_23: G = __loaded[3];
-                    let __v_24: G = __loaded[4];
-                    let __v_25: G = __loaded[5];
-                    match __v_20.as_canonical_u64() {
-                      0u64 => {
-                        match __v_21.as_canonical_u64() {
+                      _ => {
+                        match __v_12.as_canonical_u64() {
                           0u64 => {
-                            let __v_26: G = G::from_u64(0);
-                            let __v_27: G = G::from_u64(0);
-                            let __v_28: G = G::from_u64(0);
-                            let __v_29: G = G::from_u64(1);
-                            let __v_30: 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_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __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 __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_743] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                            let __v_17: G = G::from_u64(0);
+                            let __v_18: G = G::from_u64(1);
+                            let __v_19: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_20: G = { let __values: [G; 5] = [__v_18, __v_0, __v_1, __v_19, __v_15]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_21: G = G::from_u64(1);
+                            let __v_22: G = { let __values: [G; 5] = [__v_21, __v_8, __v_9, __v_16, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __ret: [G; OUT_743] = [__v_17, __v_13, __v_14, __v_20, __v_22];
                             record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
-                            let __v_26: G = G::from_u64(0);
-                            let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
+                            let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_17: G = __loaded[0];
+                            let __v_18: G = __loaded[1];
+                            let __v_19: G = __loaded[2];
+                            let __v_20: G = __loaded[3];
+                            let __v_21: G = __loaded[4];
+                            match __v_20.as_canonical_u64() {
+                              0u64 => {
+                                let __v_22: G = G::from_u64(1);
+                                let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
+                                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                match __v_17.as_canonical_u64() {
+                                  0u64 => {
+                                    let __v_22: G = G::from_u64(0);
+                                    let __v_23: G = G::from_u64(1);
+                                    let __v_24: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_25: G = { let __values: [G; 5] = [__v_23, __v_0, __v_1, __v_24, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_26: G = G::from_u64(1);
+                                    let __v_27: G = { let __values: [G; 5] = [__v_26, __v_18, __v_19, __v_20, __v_21]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __ret: [G; OUT_743] = [__v_22, __v_8, __v_9, __v_25, __v_27];
+                                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __v_22: G = G::from_u64(1);
+                                    let __v_23: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_24: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __ret: [G; OUT_743] = [__v_22, __v_0, __v_1, __v_23, __v_24];
+                                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                            }
                           },
                         }
                       },
-                      _ => {
-                        let __v_26: G = G::from_u64(0);
-                        let __v_27: G = G::from_u64(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_743] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
                     }
                   },
+                  _ => {
+                    let __v_12: G = G::from_u64(1);
+                    let __v_13: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_14: G = { let __values: [G; 5] = [__v_7, __v_8, __v_9, __v_10, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __ret: [G; OUT_743] = [__v_12, __v_0, __v_1, __v_13, __v_14];
+                    record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
                 }
               },
-              _ => {
-                let __v_14: G = G::from_u64(0);
-                let __v_15: G = G::from_u64(1);
-                let __v_16: G = { 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_743] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
             }
           },
-          _ => {
-            let __v_14: G = G::from_u64(0);
-            let __v_15: G = G::from_u64(1);
-            let __v_16: G = { 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_743] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-            record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
         }
       },
     }
diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs
index afe8ed2c..09f82329 100644
--- a/crates/ixvm-codegen/src/aiur_multi_stark.rs
+++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs
@@ -31,10 +31,8 @@ fn aiur_fn_0(
     let __v_2: G = inp[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_0] = [__v_5];
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_0] = [__v_3];
         record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -47,9 +45,8 @@ fn aiur_fn_0(
         let __v_7: G = __r_arr[0];
         let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr };
         let __v_8: G = __io_read[0];
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_0] = [__v_10];
+        let __v_9: G = { let __values: [G; 2] = [__v_8, __v_7]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_0] = [__v_9];
         record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -941,28 +938,22 @@ fn aiur_fn_21(
 ) -> Result<[G; OUT_21], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_21] = [__v_2, __v_3];
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_21] = [__v_1, __v_2];
         record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      1u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_21] = [__v_4, __v_7];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __ret: [G; OUT_21] = [__v_1, __v_2];
         record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -1290,10 +1281,8 @@ fn aiur_fn_30(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_30] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_30] = [__v_2, __v_0];
         record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1306,9 +1295,8 @@ fn aiur_fn_30(
         let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_30] = [__v_9, __v_7];
+        let __v_8: G = { let __values: [G; 2] = [__v_2, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_30] = [__v_8, __v_7];
         record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1353,10 +1341,8 @@ fn aiur_fn_32(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_32] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_32] = [__v_2, __v_0];
         record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1376,9 +1362,8 @@ fn aiur_fn_32(
         let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_10, __v_12]; 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_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __v_15: G = G::from_u64(0);
-        let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_32] = [__v_16, __v_14];
+        let __v_15: G = { let __values: [G; 9] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_32] = [__v_15, __v_14];
         record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1423,10 +1408,8 @@ fn aiur_fn_34(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_34] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_34] = [__v_2, __v_0];
         record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1440,9 +1423,8 @@ fn aiur_fn_34(
         let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_34] = [__v_10, __v_8];
+        let __v_9: G = { let __values: [G; 3] = [__v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_34] = [__v_9, __v_8];
         record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1487,10 +1469,8 @@ fn aiur_fn_36(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_36] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_36] = [__v_2, __v_0];
         record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1534,9 +1514,8 @@ fn aiur_fn_36(
         let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_34, __v_36]; 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_37: G = __r_arr[0];
         let __v_38: G = __r_arr[1];
-        let __v_39: G = G::from_u64(0);
-        let __v_40: G = { let __values: [G; 34] = [__v_39, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_37]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_36] = [__v_40, __v_38];
+        let __v_39: G = { let __values: [G; 33] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_37]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_36] = [__v_39, __v_38];
         record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1581,10 +1560,8 @@ fn aiur_fn_38(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_38] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_38] = [__v_2, __v_0];
         record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1597,9 +1574,8 @@ fn aiur_fn_38(
         let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_38] = [__v_9, __v_7];
+        let __v_8: G = { let __values: [G; 2] = [__v_2, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_38] = [__v_8, __v_7];
         record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1644,10 +1620,8 @@ fn aiur_fn_40(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_40] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_40] = [__v_2, __v_0];
         record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1660,9 +1634,8 @@ fn aiur_fn_40(
         let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_40] = [__v_9, __v_7];
+        let __v_8: G = { let __values: [G; 2] = [__v_2, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_40] = [__v_8, __v_7];
         record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1707,10 +1680,8 @@ fn aiur_fn_42(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_42] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_42] = [__v_2, __v_0];
         record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1723,9 +1694,8 @@ fn aiur_fn_42(
         let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_42] = [__v_9, __v_7];
+        let __v_8: G = { let __values: [G; 2] = [__v_2, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_42] = [__v_8, __v_7];
         record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1790,10 +1760,8 @@ fn aiur_fn_45(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_45] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_45] = [__v_2, __v_0];
         record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1806,9 +1774,8 @@ fn aiur_fn_45(
         let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_45] = [__v_9, __v_7];
+        let __v_8: G = { let __values: [G; 2] = [__v_2, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_45] = [__v_8, __v_7];
         record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1902,10 +1869,8 @@ fn aiur_fn_49(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_49] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_49] = [__v_2, __v_0];
         record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1919,9 +1884,8 @@ fn aiur_fn_49(
         let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_4, __v_6]; 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_49] = [__v_10, __v_8];
+        let __v_9: G = { let __values: [G; 3] = [__v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_49] = [__v_9, __v_8];
         record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -1992,10 +1956,8 @@ fn aiur_fn_52(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_52] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_52] = [__v_2, __v_0];
         record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -2010,9 +1972,8 @@ fn aiur_fn_52(
         let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_5, __v_7]; 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 5] = [__v_10, __v_2, __v_3, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_52] = [__v_11, __v_9];
+        let __v_10: G = { let __values: [G; 4] = [__v_2, __v_3, __v_4, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_52] = [__v_10, __v_9];
         record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -2080,10 +2041,8 @@ fn aiur_fn_55(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_55] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_55] = [__v_2, __v_0];
         record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -2097,9 +2056,8 @@ fn aiur_fn_55(
         let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_4, __v_6]; 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_55] = [__v_10, __v_8];
+        let __v_9: G = { let __values: [G; 3] = [__v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_55] = [__v_9, __v_8];
         record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -2282,9 +2240,9 @@ fn aiur_fn_59(
     let __v_30: G = G::from_u64(205);
     let __v_31: G = G::from_u64(224);
     let __v_32: G = G::from_u64(91);
-    let __v_33: G = G::from_u64(1);
-    let __v_34: G = G::from_u64(1);
-    let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_33: G = G::from_u64(0);
+    let __v_34: G = G::from_u64(0);
+    let __v_35: G = G::from_u64(0);
     let __v_36: G = G::from_u64(0);
     let __v_37: G = G::from_u64(0);
     let __v_38: G = G::from_u64(0);
@@ -2293,92 +2251,53 @@ fn aiur_fn_59(
     let __v_41: G = G::from_u64(0);
     let __v_42: G = G::from_u64(0);
     let __v_43: G = G::from_u64(0);
-    let __v_44: G = G::from_u64(0);
-    let __v_45: G = G::from_u64(0);
-    let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_48: G = G::from_u64(1);
-    let __v_49: G = G::from_u64(1);
-    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } else { aiur_fn_62(__args, record, io_buffer, __cu)? } };
-    let __v_51: G = __r_arr[0];
-    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-    let __v_52: G = __loaded[0];
-    let __v_53: G = __loaded[1];
-    let __v_54: G = __loaded[2];
-    let __v_55: G = __loaded[3];
-    let __v_56: G = __loaded[4];
-    let __v_57: G = __loaded[5];
-    let __v_58: G = __loaded[6];
-    let __v_59: G = __loaded[7];
-    let __v_60: G = __loaded[8];
-    let __v_61: G = __loaded[9];
-    let __v_62: G = __loaded[10];
-    let __v_63: G = __loaded[11];
-    let __v_64: G = __loaded[12];
-    let __v_65: G = __loaded[13];
-    let __v_66: G = __loaded[14];
-    let __v_67: G = __loaded[15];
-    let __v_68: G = __loaded[16];
-    let __v_69: G = __loaded[17];
-    let __v_70: G = __loaded[18];
-    let __v_71: G = __loaded[19];
-    let __v_72: G = __loaded[20];
-    let __v_73: G = __loaded[21];
-    let __v_74: G = __loaded[22];
-    let __v_75: G = __loaded[23];
-    let __v_76: G = __loaded[24];
-    let __v_77: G = __loaded[25];
-    let __v_78: G = __loaded[26];
-    let __v_79: G = __loaded[27];
-    let __v_80: G = __loaded[28];
-    let __v_81: G = __loaded[29];
-    let __v_82: G = __loaded[30];
-    let __v_83: G = __loaded[31];
-    let __v_84: G = __loaded[32];
-    let __v_85: G = __loaded[33];
-    let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__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[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_86: G = __r_arr[0];
-    let __v_87: G = __r_arr[1];
-    let __v_88: G = __r_arr[2];
-    let __v_89: G = __r_arr[3];
-    let __v_90: G = __r_arr[4];
-    let __v_91: G = __r_arr[5];
-    let __v_92: G = __r_arr[6];
-    let __v_93: G = __r_arr[7];
-    let __v_94: G = __r_arr[8];
-    let __v_95: G = __r_arr[9];
-    let __v_96: G = __r_arr[10];
-    let __v_97: G = __r_arr[11];
-    let __v_98: G = __r_arr[12];
-    let __v_99: G = __r_arr[13];
-    let __v_100: G = __r_arr[14];
-    let __v_101: G = __r_arr[15];
-    let __v_102: G = __r_arr[16];
-    let __v_103: G = __r_arr[17];
-    let __v_104: G = __r_arr[18];
-    let __v_105: G = __r_arr[19];
-    let __v_106: G = __r_arr[20];
-    let __v_107: G = __r_arr[21];
-    let __v_108: G = __r_arr[22];
-    let __v_109: G = __r_arr[23];
-    let __v_110: G = __r_arr[24];
-    let __v_111: G = __r_arr[25];
-    let __v_112: G = __r_arr[26];
-    let __v_113: G = __r_arr[27];
-    let __v_114: G = __r_arr[28];
-    let __v_115: G = __r_arr[29];
-    let __v_116: G = __r_arr[30];
-    let __v_117: G = __r_arr[31];
-    let __ret: [G; OUT_59] = [__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 __v_44: G = { let __values: [G; 8] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_45: 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_46: G = G::from_u64(0);
+    let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_0, __v_33, __v_34, __v_35, __v_44, __v_45, __v_46]; 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_47: G = __r_arr[0];
+    let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_47]; 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_48: G = __r_arr[0];
+    let __v_49: G = __r_arr[1];
+    let __v_50: G = __r_arr[2];
+    let __v_51: G = __r_arr[3];
+    let __v_52: G = __r_arr[4];
+    let __v_53: G = __r_arr[5];
+    let __v_54: G = __r_arr[6];
+    let __v_55: G = __r_arr[7];
+    let __v_56: G = __r_arr[8];
+    let __v_57: G = __r_arr[9];
+    let __v_58: G = __r_arr[10];
+    let __v_59: G = __r_arr[11];
+    let __v_60: G = __r_arr[12];
+    let __v_61: G = __r_arr[13];
+    let __v_62: G = __r_arr[14];
+    let __v_63: G = __r_arr[15];
+    let __v_64: G = __r_arr[16];
+    let __v_65: G = __r_arr[17];
+    let __v_66: G = __r_arr[18];
+    let __v_67: G = __r_arr[19];
+    let __v_68: G = __r_arr[20];
+    let __v_69: G = __r_arr[21];
+    let __v_70: G = __r_arr[22];
+    let __v_71: G = __r_arr[23];
+    let __v_72: G = __r_arr[24];
+    let __v_73: G = __r_arr[25];
+    let __v_74: G = __r_arr[26];
+    let __v_75: G = __r_arr[27];
+    let __v_76: G = __r_arr[28];
+    let __v_77: G = __r_arr[29];
+    let __v_78: G = __r_arr[30];
+    let __v_79: G = __r_arr[31];
+    let __ret: [G; OUT_59] = [__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];
     record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_60: usize = 67;
-const IN_60: usize = 67;
-const OUT_60: usize = 67;
+const INPUT_SIZE_60: usize = 34;
+const IN_60: usize = 34;
+const OUT_60: usize = 34;
 fn aiur_fn_60(
   inp: [G; IN_60],
   record: &mut QueryRecord,
@@ -2420,361 +2339,16 @@ fn aiur_fn_60(
     let __v_31: G = inp[31];
     let __v_32: G = inp[32];
     let __v_33: G = inp[33];
-    let __v_34: G = inp[34];
-    let __v_35: G = inp[35];
-    let __v_36: G = inp[36];
-    let __v_37: G = inp[37];
-    let __v_38: G = inp[38];
-    let __v_39: G = inp[39];
-    let __v_40: G = inp[40];
-    let __v_41: G = inp[41];
-    let __v_42: G = inp[42];
-    let __v_43: G = inp[43];
-    let __v_44: G = inp[44];
-    let __v_45: G = inp[45];
-    let __v_46: G = inp[46];
-    let __v_47: G = inp[47];
-    let __v_48: G = inp[48];
-    let __v_49: G = inp[49];
-    let __v_50: G = inp[50];
-    let __v_51: G = inp[51];
-    let __v_52: G = inp[52];
-    let __v_53: G = inp[53];
-    let __v_54: G = inp[54];
-    let __v_55: G = inp[55];
-    let __v_56: G = inp[56];
-    let __v_57: G = inp[57];
-    let __v_58: G = inp[58];
-    let __v_59: G = inp[59];
-    let __v_60: G = inp[60];
-    let __v_61: G = inp[61];
-    let __v_62: G = inp[62];
-    let __v_63: G = inp[63];
-    let __v_64: G = inp[64];
-    let __v_65: G = inp[65];
-    let __v_66: G = inp[66];
     match __v_0.as_canonical_u64() {
-      1u64 => {
-        let __v_67: G = G::from_u64(1);
-        let __v_68: G = G::from_u64(1);
-        let __v_69: G = G::from_u64(1);
-        let __ret: [G; OUT_60] = [__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];
+      0u64 => {
+        let __v_34: G = G::from_u64(1);
+        let __v_35: G = G::from_u64(0);
+        let __ret: [G; OUT_60] = [__v_34, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_35];
         record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-        let __v_67: G = __loaded[0];
-        let __v_68: G = __loaded[1];
-        let __v_69: G = __loaded[2];
-        let __v_70: G = __loaded[3];
-        let __v_71: G = __loaded[4];
-        let __v_72: G = __loaded[5];
-        let __v_73: G = __loaded[6];
-        let __v_74: G = __loaded[7];
-        let __v_75: G = __loaded[8];
-        let __v_76: G = __loaded[9];
-        let __v_77: G = __loaded[10];
-        let __v_78: G = __loaded[11];
-        let __v_79: G = __loaded[12];
-        let __v_80: G = __loaded[13];
-        let __v_81: G = __loaded[14];
-        let __v_82: G = __loaded[15];
-        let __v_83: G = __loaded[16];
-        let __v_84: G = __loaded[17];
-        let __v_85: G = __loaded[18];
-        let __v_86: G = __loaded[19];
-        let __v_87: G = __loaded[20];
-        let __v_88: G = __loaded[21];
-        let __v_89: G = __loaded[22];
-        let __v_90: G = __loaded[23];
-        let __v_91: G = __loaded[24];
-        let __v_92: G = __loaded[25];
-        let __v_93: G = __loaded[26];
-        let __v_94: G = __loaded[27];
-        let __v_95: G = __loaded[28];
-        let __v_96: G = __loaded[29];
-        let __v_97: G = __loaded[30];
-        let __v_98: G = __loaded[31];
-        let __v_99: G = __loaded[32];
-        let __v_100: G = __loaded[33];
-        let __v_101: G = G::from_u64(0);
-        let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__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[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_102: G = __r_arr[0];
-        let __v_103: G = __r_arr[1];
-        let __v_104: G = __r_arr[2];
-        let __v_105: G = __r_arr[3];
-        let __v_106: G = __r_arr[4];
-        let __v_107: G = __r_arr[5];
-        let __v_108: G = __r_arr[6];
-        let __v_109: G = __r_arr[7];
-        let __v_110: G = __r_arr[8];
-        let __v_111: G = __r_arr[9];
-        let __v_112: G = __r_arr[10];
-        let __v_113: G = __r_arr[11];
-        let __v_114: G = __r_arr[12];
-        let __v_115: G = __r_arr[13];
-        let __v_116: G = __r_arr[14];
-        let __v_117: G = __r_arr[15];
-        let __v_118: G = __r_arr[16];
-        let __v_119: G = __r_arr[17];
-        let __v_120: G = __r_arr[18];
-        let __v_121: G = __r_arr[19];
-        let __v_122: G = __r_arr[20];
-        let __v_123: G = __r_arr[21];
-        let __v_124: G = __r_arr[22];
-        let __v_125: G = __r_arr[23];
-        let __v_126: G = __r_arr[24];
-        let __v_127: G = __r_arr[25];
-        let __v_128: G = __r_arr[26];
-        let __v_129: G = __r_arr[27];
-        let __v_130: G = __r_arr[28];
-        let __v_131: G = __r_arr[29];
-        let __v_132: G = __r_arr[30];
-        let __v_133: G = __r_arr[31];
-        let __v_134: G = __r_arr[32];
-        let __v_135: G = __r_arr[33];
-        let __v_136: G = __r_arr[34];
-        let __v_137: G = __r_arr[35];
-        let __v_138: G = __r_arr[36];
-        let __v_139: G = __r_arr[37];
-        let __v_140: G = __r_arr[38];
-        let __v_141: G = __r_arr[39];
-        let __v_142: G = __r_arr[40];
-        let __v_143: G = __r_arr[41];
-        let __v_144: G = __r_arr[42];
-        let __v_145: G = __r_arr[43];
-        let __v_146: G = __r_arr[44];
-        let __v_147: G = __r_arr[45];
-        let __v_148: G = __r_arr[46];
-        let __v_149: G = __r_arr[47];
-        let __v_150: G = __r_arr[48];
-        let __v_151: G = __r_arr[49];
-        let __v_152: G = __r_arr[50];
-        let __v_153: G = __r_arr[51];
-        let __v_154: G = __r_arr[52];
-        let __v_155: G = __r_arr[53];
-        let __v_156: G = __r_arr[54];
-        let __v_157: G = __r_arr[55];
-        let __v_158: G = __r_arr[56];
-        let __v_159: G = __r_arr[57];
-        let __v_160: G = __r_arr[58];
-        let __v_161: G = __r_arr[59];
-        let __v_162: G = __r_arr[60];
-        let __v_163: G = __r_arr[61];
-        let __v_164: G = __r_arr[62];
-        let __v_165: G = __r_arr[63];
-        let __v_166: G = __r_arr[64];
-        let __v_167: G = __r_arr[65];
-        let __v_168: G = __r_arr[66];
-        match __v_102.as_canonical_u64() {
-          0u64 => {
-            let __v_169: G = G::from_u64(1);
-            let __ret: [G; OUT_60] = [__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[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_169: G = G::from_u64(4);
-            let __v_170: G = G::from_u64(8);
-            let __v_171: G = G::from_u64(103);
-            let __v_172: G = G::from_u64(230);
-            let __v_173: G = G::from_u64(9);
-            let __v_174: G = G::from_u64(106);
-            let __v_175: G = G::from_u64(133);
-            let __v_176: G = G::from_u64(174);
-            let __v_177: G = G::from_u64(103);
-            let __v_178: G = G::from_u64(187);
-            let __v_179: G = G::from_u64(114);
-            let __v_180: G = G::from_u64(243);
-            let __v_181: G = G::from_u64(110);
-            let __v_182: G = G::from_u64(60);
-            let __v_183: G = G::from_u64(58);
-            let __v_184: G = G::from_u64(245);
-            let __v_185: G = G::from_u64(79);
-            let __v_186: G = G::from_u64(165);
-            let __v_187: G = G::from_u64(127);
-            let __v_188: G = G::from_u64(82);
-            let __v_189: G = G::from_u64(14);
-            let __v_190: G = G::from_u64(81);
-            let __v_191: G = G::from_u64(140);
-            let __v_192: G = G::from_u64(104);
-            let __v_193: G = G::from_u64(5);
-            let __v_194: G = G::from_u64(155);
-            let __v_195: G = G::from_u64(171);
-            let __v_196: G = G::from_u64(217);
-            let __v_197: G = G::from_u64(131);
-            let __v_198: G = G::from_u64(31);
-            let __v_199: G = G::from_u64(25);
-            let __v_200: G = G::from_u64(205);
-            let __v_201: G = G::from_u64(224);
-            let __v_202: G = G::from_u64(91);
-            match __v_135.as_canonical_u64() {
-              1u64 => {
-                let __v_203: G = (__v_170 * __v_66);
-                let __v_204: G = (__v_169 + __v_203);
-                let __v_205: G = G::from_u64(0);
-                let __v_206: G = G::from_u64(0);
-                let __v_207: G = G::from_u64(0);
-                let __v_208: G = G::from_u64(0);
-                let __v_209: G = G::from_u64(0);
-                let __v_210: G = G::from_u64(0);
-                let __v_211: G = G::from_u64(0);
-                let __v_212: G = G::from_u64(0);
-                let __v_213: G = G::from_u64(64);
-                let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__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[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_214: G = __r_arr[0];
-                let __v_215: G = __r_arr[1];
-                let __v_216: G = __r_arr[2];
-                let __v_217: G = __r_arr[3];
-                let __v_218: G = __r_arr[4];
-                let __v_219: G = __r_arr[5];
-                let __v_220: G = __r_arr[6];
-                let __v_221: G = __r_arr[7];
-                let __v_222: G = __r_arr[8];
-                let __v_223: G = __r_arr[9];
-                let __v_224: G = __r_arr[10];
-                let __v_225: G = __r_arr[11];
-                let __v_226: G = __r_arr[12];
-                let __v_227: G = __r_arr[13];
-                let __v_228: G = __r_arr[14];
-                let __v_229: G = __r_arr[15];
-                let __v_230: G = __r_arr[16];
-                let __v_231: G = __r_arr[17];
-                let __v_232: G = __r_arr[18];
-                let __v_233: G = __r_arr[19];
-                let __v_234: G = __r_arr[20];
-                let __v_235: G = __r_arr[21];
-                let __v_236: G = __r_arr[22];
-                let __v_237: G = __r_arr[23];
-                let __v_238: G = __r_arr[24];
-                let __v_239: G = __r_arr[25];
-                let __v_240: G = __r_arr[26];
-                let __v_241: G = __r_arr[27];
-                let __v_242: G = __r_arr[28];
-                let __v_243: G = __r_arr[29];
-                let __v_244: G = __r_arr[30];
-                let __v_245: G = __r_arr[31];
-                let __v_246: G = G::from_u64(0);
-                let __v_247: G = G::from_u64(0);
-                let __v_248: G = G::from_u64(0);
-                let __v_249: G = { let __values: [G; 34] = [__v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_60] = [__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[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_203: G = G::from_u64(0);
-                let __v_204: G = G::from_u64(0);
-                let __v_205: G = G::from_u64(0);
-                let __v_206: G = G::from_u64(0);
-                let __v_207: G = G::from_u64(0);
-                let __v_208: G = G::from_u64(0);
-                let __v_209: G = G::from_u64(0);
-                let __v_210: G = G::from_u64(0);
-                let __v_211: G = G::from_u64(64);
-                let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__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[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_212: G = __r_arr[0];
-                let __v_213: G = __r_arr[1];
-                let __v_214: G = __r_arr[2];
-                let __v_215: G = __r_arr[3];
-                let __v_216: G = __r_arr[4];
-                let __v_217: G = __r_arr[5];
-                let __v_218: G = __r_arr[6];
-                let __v_219: G = __r_arr[7];
-                let __v_220: G = __r_arr[8];
-                let __v_221: G = __r_arr[9];
-                let __v_222: G = __r_arr[10];
-                let __v_223: G = __r_arr[11];
-                let __v_224: G = __r_arr[12];
-                let __v_225: G = __r_arr[13];
-                let __v_226: G = __r_arr[14];
-                let __v_227: G = __r_arr[15];
-                let __v_228: G = __r_arr[16];
-                let __v_229: G = __r_arr[17];
-                let __v_230: G = __r_arr[18];
-                let __v_231: G = __r_arr[19];
-                let __v_232: G = __r_arr[20];
-                let __v_233: G = __r_arr[21];
-                let __v_234: G = __r_arr[22];
-                let __v_235: G = __r_arr[23];
-                let __v_236: G = __r_arr[24];
-                let __v_237: G = __r_arr[25];
-                let __v_238: G = __r_arr[26];
-                let __v_239: G = __r_arr[27];
-                let __v_240: G = __r_arr[28];
-                let __v_241: G = __r_arr[29];
-                let __v_242: G = __r_arr[30];
-                let __v_243: G = __r_arr[31];
-                let __v_244: G = G::from_u64(0);
-                let __v_245: G = G::from_u64(0);
-                let __v_246: G = G::from_u64(0);
-                let __v_247: G = { let __values: [G; 34] = [__v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_60] = [__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[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_102.as_canonical_u64()));
-          },
-        }
-      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_61: usize = 34;
-const IN_61: usize = 34;
-const OUT_61: usize = 32;
-fn aiur_fn_61(
-  inp: [G; IN_61],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_61], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    let __v_31: G = inp[31];
-    let __v_32: G = inp[32];
-    let __v_33: G = inp[33];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+        let __loaded: [G; 33] = { let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 33 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 33] = __args[..33].try_into().unwrap(); __arr };
         let __v_34: G = __loaded[0];
         let __v_35: G = __loaded[1];
         let __v_36: G = __loaded[2];
@@ -2808,207 +2382,383 @@ fn aiur_fn_61(
         let __v_64: G = __loaded[30];
         let __v_65: G = __loaded[31];
         let __v_66: G = __loaded[32];
-        let __v_67: G = __loaded[33];
-        match __v_34.as_canonical_u64() {
+        let __v_67: G = G::from_u64(0);
+        let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_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]; 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_68: G = __r_arr[0];
+        let __v_69: G = __r_arr[1];
+        let __v_70: G = __r_arr[2];
+        let __v_71: G = __r_arr[3];
+        let __v_72: G = __r_arr[4];
+        let __v_73: G = __r_arr[5];
+        let __v_74: G = __r_arr[6];
+        let __v_75: G = __r_arr[7];
+        let __v_76: G = __r_arr[8];
+        let __v_77: G = __r_arr[9];
+        let __v_78: G = __r_arr[10];
+        let __v_79: G = __r_arr[11];
+        let __v_80: G = __r_arr[12];
+        let __v_81: G = __r_arr[13];
+        let __v_82: G = __r_arr[14];
+        let __v_83: G = __r_arr[15];
+        let __v_84: G = __r_arr[16];
+        let __v_85: G = __r_arr[17];
+        let __v_86: G = __r_arr[18];
+        let __v_87: G = __r_arr[19];
+        let __v_88: G = __r_arr[20];
+        let __v_89: G = __r_arr[21];
+        let __v_90: G = __r_arr[22];
+        let __v_91: G = __r_arr[23];
+        let __v_92: G = __r_arr[24];
+        let __v_93: G = __r_arr[25];
+        let __v_94: G = __r_arr[26];
+        let __v_95: G = __r_arr[27];
+        let __v_96: G = __r_arr[28];
+        let __v_97: G = __r_arr[29];
+        let __v_98: G = __r_arr[30];
+        let __v_99: G = __r_arr[31];
+        let __v_100: G = __r_arr[32];
+        let __v_101: G = __r_arr[33];
+        match __v_68.as_canonical_u64() {
+          0u64 => {
+            let __v_102: G = G::from_u64(1);
+            let __ret: [G; OUT_60] = [__v_102, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_101];
+            record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
           1u64 => {
+            let __v_102: G = G::from_u64(4);
+            let __v_103: G = G::from_u64(8);
+            let __v_104: G = G::from_u64(103);
+            let __v_105: G = G::from_u64(230);
+            let __v_106: G = G::from_u64(9);
+            let __v_107: G = G::from_u64(106);
+            let __v_108: G = G::from_u64(133);
+            let __v_109: G = G::from_u64(174);
+            let __v_110: G = G::from_u64(103);
+            let __v_111: G = G::from_u64(187);
+            let __v_112: G = G::from_u64(114);
+            let __v_113: G = G::from_u64(243);
+            let __v_114: G = G::from_u64(110);
+            let __v_115: G = G::from_u64(60);
+            let __v_116: G = G::from_u64(58);
+            let __v_117: G = G::from_u64(245);
+            let __v_118: G = G::from_u64(79);
+            let __v_119: G = G::from_u64(165);
+            let __v_120: G = G::from_u64(127);
+            let __v_121: G = G::from_u64(82);
+            let __v_122: G = G::from_u64(14);
+            let __v_123: G = G::from_u64(81);
+            let __v_124: G = G::from_u64(140);
+            let __v_125: G = G::from_u64(104);
+            let __v_126: G = G::from_u64(5);
+            let __v_127: G = G::from_u64(155);
+            let __v_128: G = G::from_u64(171);
+            let __v_129: G = G::from_u64(217);
+            let __v_130: G = G::from_u64(131);
+            let __v_131: G = G::from_u64(31);
+            let __v_132: G = G::from_u64(25);
+            let __v_133: G = G::from_u64(205);
+            let __v_134: G = G::from_u64(224);
+            let __v_135: G = G::from_u64(91);
+            match __v_101.as_canonical_u64() {
+              0u64 => {
+                let __v_136: G = (__v_103 * __v_33);
+                let __v_137: G = (__v_102 + __v_136);
+                let __v_138: G = G::from_u64(0);
+                let __v_139: G = G::from_u64(0);
+                let __v_140: G = G::from_u64(0);
+                let __v_141: G = G::from_u64(0);
+                let __v_142: G = G::from_u64(0);
+                let __v_143: G = G::from_u64(0);
+                let __v_144: G = G::from_u64(0);
+                let __v_145: G = G::from_u64(0);
+                let __v_146: G = G::from_u64(64);
+                let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__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, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_137]; 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_147: G = __r_arr[0];
+                let __v_148: G = __r_arr[1];
+                let __v_149: G = __r_arr[2];
+                let __v_150: G = __r_arr[3];
+                let __v_151: G = __r_arr[4];
+                let __v_152: G = __r_arr[5];
+                let __v_153: G = __r_arr[6];
+                let __v_154: G = __r_arr[7];
+                let __v_155: G = __r_arr[8];
+                let __v_156: G = __r_arr[9];
+                let __v_157: G = __r_arr[10];
+                let __v_158: G = __r_arr[11];
+                let __v_159: G = __r_arr[12];
+                let __v_160: G = __r_arr[13];
+                let __v_161: G = __r_arr[14];
+                let __v_162: G = __r_arr[15];
+                let __v_163: G = __r_arr[16];
+                let __v_164: G = __r_arr[17];
+                let __v_165: G = __r_arr[18];
+                let __v_166: G = __r_arr[19];
+                let __v_167: G = __r_arr[20];
+                let __v_168: G = __r_arr[21];
+                let __v_169: G = __r_arr[22];
+                let __v_170: G = __r_arr[23];
+                let __v_171: G = __r_arr[24];
+                let __v_172: G = __r_arr[25];
+                let __v_173: G = __r_arr[26];
+                let __v_174: G = __r_arr[27];
+                let __v_175: G = __r_arr[28];
+                let __v_176: G = __r_arr[29];
+                let __v_177: G = __r_arr[30];
+                let __v_178: G = __r_arr[31];
+                let __v_179: G = G::from_u64(0);
+                let __v_180: G = G::from_u64(0);
+                let __v_181: G = { let __values: [G; 33] = [__v_101, __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]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_60] = [__v_179, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_180, __v_181];
+                record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_136: G = G::from_u64(0);
+                let __v_137: G = G::from_u64(0);
+                let __v_138: G = G::from_u64(0);
+                let __v_139: G = G::from_u64(0);
+                let __v_140: G = G::from_u64(0);
+                let __v_141: G = G::from_u64(0);
+                let __v_142: G = G::from_u64(0);
+                let __v_143: G = G::from_u64(0);
+                let __v_144: G = G::from_u64(64);
+                let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__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, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_102]; 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_145: G = __r_arr[0];
+                let __v_146: G = __r_arr[1];
+                let __v_147: G = __r_arr[2];
+                let __v_148: G = __r_arr[3];
+                let __v_149: G = __r_arr[4];
+                let __v_150: G = __r_arr[5];
+                let __v_151: G = __r_arr[6];
+                let __v_152: G = __r_arr[7];
+                let __v_153: G = __r_arr[8];
+                let __v_154: G = __r_arr[9];
+                let __v_155: G = __r_arr[10];
+                let __v_156: G = __r_arr[11];
+                let __v_157: G = __r_arr[12];
+                let __v_158: G = __r_arr[13];
+                let __v_159: G = __r_arr[14];
+                let __v_160: G = __r_arr[15];
+                let __v_161: G = __r_arr[16];
+                let __v_162: G = __r_arr[17];
+                let __v_163: G = __r_arr[18];
+                let __v_164: G = __r_arr[19];
+                let __v_165: G = __r_arr[20];
+                let __v_166: G = __r_arr[21];
+                let __v_167: G = __r_arr[22];
+                let __v_168: G = __r_arr[23];
+                let __v_169: G = __r_arr[24];
+                let __v_170: G = __r_arr[25];
+                let __v_171: G = __r_arr[26];
+                let __v_172: G = __r_arr[27];
+                let __v_173: G = __r_arr[28];
+                let __v_174: G = __r_arr[29];
+                let __v_175: G = __r_arr[30];
+                let __v_176: G = __r_arr[31];
+                let __v_177: G = G::from_u64(0);
+                let __v_178: G = G::from_u64(0);
+                let __v_179: G = { let __values: [G; 33] = [__v_101, __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]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_60] = [__v_177, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_178, __v_179];
+                record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_68.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_61: usize = 1;
+const IN_61: usize = 1;
+const OUT_61: usize = 32;
+fn aiur_fn_61(
+  inp: [G; IN_61],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_61], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(1);
+        if (__v_1 != __v_2) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_61] = [__v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1];
+        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 33] = { let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 33 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 33] = __args[..33].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __v_10: G = __loaded[9];
+        let __v_11: G = __loaded[10];
+        let __v_12: G = __loaded[11];
+        let __v_13: G = __loaded[12];
+        let __v_14: G = __loaded[13];
+        let __v_15: G = __loaded[14];
+        let __v_16: G = __loaded[15];
+        let __v_17: G = __loaded[16];
+        let __v_18: G = __loaded[17];
+        let __v_19: G = __loaded[18];
+        let __v_20: G = __loaded[19];
+        let __v_21: G = __loaded[20];
+        let __v_22: G = __loaded[21];
+        let __v_23: G = __loaded[22];
+        let __v_24: G = __loaded[23];
+        let __v_25: G = __loaded[24];
+        let __v_26: G = __loaded[25];
+        let __v_27: G = __loaded[26];
+        let __v_28: G = __loaded[27];
+        let __v_29: G = __loaded[28];
+        let __v_30: G = __loaded[29];
+        let __v_31: G = __loaded[30];
+        let __v_32: G = __loaded[31];
+        let __v_33: G = __loaded[32];
+        match __v_1.as_canonical_u64() {
+          0u64 => {
             let __ret: [G; OUT_61] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __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[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-            let __v_68: G = __loaded[0];
-            let __v_69: G = __loaded[1];
-            let __v_70: G = __loaded[2];
-            let __v_71: G = __loaded[3];
-            let __v_72: G = __loaded[4];
-            let __v_73: G = __loaded[5];
-            let __v_74: G = __loaded[6];
-            let __v_75: G = __loaded[7];
-            let __v_76: G = __loaded[8];
-            let __v_77: G = __loaded[9];
-            let __v_78: G = __loaded[10];
-            let __v_79: G = __loaded[11];
-            let __v_80: G = __loaded[12];
-            let __v_81: G = __loaded[13];
-            let __v_82: G = __loaded[14];
-            let __v_83: G = __loaded[15];
-            let __v_84: G = __loaded[16];
-            let __v_85: G = __loaded[17];
-            let __v_86: G = __loaded[18];
-            let __v_87: G = __loaded[19];
-            let __v_88: G = __loaded[20];
-            let __v_89: G = __loaded[21];
-            let __v_90: G = __loaded[22];
-            let __v_91: G = __loaded[23];
-            let __v_92: G = __loaded[24];
-            let __v_93: G = __loaded[25];
-            let __v_94: G = __loaded[26];
-            let __v_95: G = __loaded[27];
-            let __v_96: G = __loaded[28];
-            let __v_97: G = __loaded[29];
-            let __v_98: G = __loaded[30];
-            let __v_99: G = __loaded[31];
-            let __v_100: G = __loaded[32];
-            let __v_101: G = __loaded[33];
-            let __v_102: G = G::from_u64(1);
-            let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__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[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_103: G = __r_arr[0];
-            let __v_104: G = __r_arr[1];
-            let __v_105: G = __r_arr[2];
-            let __v_106: G = __r_arr[3];
-            let __v_107: G = __r_arr[4];
-            let __v_108: G = __r_arr[5];
-            let __v_109: G = __r_arr[6];
-            let __v_110: G = __r_arr[7];
-            let __v_111: G = __r_arr[8];
-            let __v_112: G = __r_arr[9];
-            let __v_113: G = __r_arr[10];
-            let __v_114: G = __r_arr[11];
-            let __v_115: G = __r_arr[12];
-            let __v_116: G = __r_arr[13];
-            let __v_117: G = __r_arr[14];
-            let __v_118: G = __r_arr[15];
-            let __v_119: G = __r_arr[16];
-            let __v_120: G = __r_arr[17];
-            let __v_121: G = __r_arr[18];
-            let __v_122: G = __r_arr[19];
-            let __v_123: G = __r_arr[20];
-            let __v_124: G = __r_arr[21];
-            let __v_125: G = __r_arr[22];
-            let __v_126: G = __r_arr[23];
-            let __v_127: G = __r_arr[24];
-            let __v_128: G = __r_arr[25];
-            let __v_129: G = __r_arr[26];
-            let __v_130: G = __r_arr[27];
-            let __v_131: G = __r_arr[28];
-            let __v_132: G = __r_arr[29];
-            let __v_133: G = __r_arr[30];
-            let __v_134: G = __r_arr[31];
-            let __v_135: G = __r_arr[32];
-            let __v_136: G = __r_arr[33];
-            let __v_137: G = __r_arr[34];
-            let __v_138: G = __r_arr[35];
-            let __v_139: G = __r_arr[36];
-            let __v_140: G = __r_arr[37];
-            let __v_141: G = __r_arr[38];
-            let __v_142: G = __r_arr[39];
-            let __v_143: G = __r_arr[40];
-            let __v_144: G = __r_arr[41];
-            let __v_145: G = __r_arr[42];
-            let __v_146: G = __r_arr[43];
-            let __v_147: G = __r_arr[44];
-            let __v_148: G = __r_arr[45];
-            let __v_149: G = __r_arr[46];
-            let __v_150: G = __r_arr[47];
-            let __v_151: G = __r_arr[48];
-            let __v_152: G = __r_arr[49];
-            let __v_153: G = __r_arr[50];
-            let __v_154: G = __r_arr[51];
-            let __v_155: G = __r_arr[52];
-            let __v_156: G = __r_arr[53];
-            let __v_157: G = __r_arr[54];
-            let __v_158: G = __r_arr[55];
-            let __v_159: G = __r_arr[56];
-            let __v_160: G = __r_arr[57];
-            let __v_161: G = __r_arr[58];
-            let __v_162: G = __r_arr[59];
-            let __v_163: G = __r_arr[60];
-            let __v_164: G = __r_arr[61];
-            let __v_165: G = __r_arr[62];
-            let __v_166: G = __r_arr[63];
-            let __v_167: G = __r_arr[64];
-            let __v_168: G = __r_arr[65];
-            let __v_169: G = __r_arr[66];
-            match __v_103.as_canonical_u64() {
+            let __v_34: 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_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; 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_35: G = __r_arr[0];
+            let __v_36: G = __r_arr[1];
+            let __v_37: G = __r_arr[2];
+            let __v_38: G = __r_arr[3];
+            let __v_39: G = __r_arr[4];
+            let __v_40: G = __r_arr[5];
+            let __v_41: G = __r_arr[6];
+            let __v_42: G = __r_arr[7];
+            let __v_43: G = __r_arr[8];
+            let __v_44: G = __r_arr[9];
+            let __v_45: G = __r_arr[10];
+            let __v_46: G = __r_arr[11];
+            let __v_47: G = __r_arr[12];
+            let __v_48: G = __r_arr[13];
+            let __v_49: G = __r_arr[14];
+            let __v_50: G = __r_arr[15];
+            let __v_51: G = __r_arr[16];
+            let __v_52: G = __r_arr[17];
+            let __v_53: G = __r_arr[18];
+            let __v_54: G = __r_arr[19];
+            let __v_55: G = __r_arr[20];
+            let __v_56: G = __r_arr[21];
+            let __v_57: G = __r_arr[22];
+            let __v_58: G = __r_arr[23];
+            let __v_59: G = __r_arr[24];
+            let __v_60: G = __r_arr[25];
+            let __v_61: G = __r_arr[26];
+            let __v_62: G = __r_arr[27];
+            let __v_63: G = __r_arr[28];
+            let __v_64: G = __r_arr[29];
+            let __v_65: G = __r_arr[30];
+            let __v_66: G = __r_arr[31];
+            let __v_67: G = __r_arr[32];
+            let __v_68: G = __r_arr[33];
+            match __v_35.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__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[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_170: G = __r_arr[0];
-                let __v_171: G = __r_arr[1];
-                let __v_172: G = __r_arr[2];
-                let __v_173: G = __r_arr[3];
-                let __v_174: G = __r_arr[4];
-                let __v_175: G = __r_arr[5];
-                let __v_176: G = __r_arr[6];
-                let __v_177: G = __r_arr[7];
-                let __v_178: G = __r_arr[8];
-                let __v_179: G = __r_arr[9];
-                let __v_180: G = __r_arr[10];
-                let __v_181: G = __r_arr[11];
-                let __v_182: G = __r_arr[12];
-                let __v_183: G = __r_arr[13];
-                let __v_184: G = __r_arr[14];
-                let __v_185: G = __r_arr[15];
-                let __v_186: G = __r_arr[16];
-                let __v_187: G = __r_arr[17];
-                let __v_188: G = __r_arr[18];
-                let __v_189: G = __r_arr[19];
-                let __v_190: G = __r_arr[20];
-                let __v_191: G = __r_arr[21];
-                let __v_192: G = __r_arr[22];
-                let __v_193: G = __r_arr[23];
-                let __v_194: G = __r_arr[24];
-                let __v_195: G = __r_arr[25];
-                let __v_196: G = __r_arr[26];
-                let __v_197: G = __r_arr[27];
-                let __v_198: G = __r_arr[28];
-                let __v_199: G = __r_arr[29];
-                let __v_200: G = __r_arr[30];
-                let __v_201: G = __r_arr[31];
-                let __ret: [G; OUT_61] = [__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];
+                let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_68]; 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_69: G = __r_arr[0];
+                let __v_70: G = __r_arr[1];
+                let __v_71: G = __r_arr[2];
+                let __v_72: G = __r_arr[3];
+                let __v_73: G = __r_arr[4];
+                let __v_74: G = __r_arr[5];
+                let __v_75: G = __r_arr[6];
+                let __v_76: G = __r_arr[7];
+                let __v_77: G = __r_arr[8];
+                let __v_78: G = __r_arr[9];
+                let __v_79: G = __r_arr[10];
+                let __v_80: G = __r_arr[11];
+                let __v_81: G = __r_arr[12];
+                let __v_82: G = __r_arr[13];
+                let __v_83: G = __r_arr[14];
+                let __v_84: G = __r_arr[15];
+                let __v_85: G = __r_arr[16];
+                let __v_86: G = __r_arr[17];
+                let __v_87: G = __r_arr[18];
+                let __v_88: G = __r_arr[19];
+                let __v_89: G = __r_arr[20];
+                let __v_90: G = __r_arr[21];
+                let __v_91: G = __r_arr[22];
+                let __v_92: G = __r_arr[23];
+                let __v_93: G = __r_arr[24];
+                let __v_94: G = __r_arr[25];
+                let __v_95: G = __r_arr[26];
+                let __v_96: G = __r_arr[27];
+                let __v_97: G = __r_arr[28];
+                let __v_98: G = __r_arr[29];
+                let __v_99: G = __r_arr[30];
+                let __v_100: G = __r_arr[31];
+                let __ret: [G; OUT_61] = [__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];
                 record.function_queries[61].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_61] = { let __args: [G; IN_61] = [__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[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_172: G = __r_arr[0];
-                let __v_173: G = __r_arr[1];
-                let __v_174: G = __r_arr[2];
-                let __v_175: G = __r_arr[3];
-                let __v_176: G = __r_arr[4];
-                let __v_177: G = __r_arr[5];
-                let __v_178: G = __r_arr[6];
-                let __v_179: G = __r_arr[7];
-                let __v_180: G = __r_arr[8];
-                let __v_181: G = __r_arr[9];
-                let __v_182: G = __r_arr[10];
-                let __v_183: G = __r_arr[11];
-                let __v_184: G = __r_arr[12];
-                let __v_185: G = __r_arr[13];
-                let __v_186: G = __r_arr[14];
-                let __v_187: G = __r_arr[15];
-                let __v_188: G = __r_arr[16];
-                let __v_189: G = __r_arr[17];
-                let __v_190: G = __r_arr[18];
-                let __v_191: G = __r_arr[19];
-                let __v_192: G = __r_arr[20];
-                let __v_193: G = __r_arr[21];
-                let __v_194: G = __r_arr[22];
-                let __v_195: G = __r_arr[23];
-                let __v_196: G = __r_arr[24];
-                let __v_197: G = __r_arr[25];
-                let __v_198: G = __r_arr[26];
-                let __v_199: G = __r_arr[27];
-                let __v_200: G = __r_arr[28];
-                let __v_201: G = __r_arr[29];
-                let __v_202: G = __r_arr[30];
-                let __v_203: G = __r_arr[31];
-                let __ret: [G; OUT_61] = [__v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203];
+                let __v_69: G = { let __values: [G; 33] = [__v_68, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } else { aiur_fn_61(__args, record, io_buffer, __cu)? } };
+                let __v_70: G = __r_arr[0];
+                let __v_71: G = __r_arr[1];
+                let __v_72: G = __r_arr[2];
+                let __v_73: G = __r_arr[3];
+                let __v_74: G = __r_arr[4];
+                let __v_75: G = __r_arr[5];
+                let __v_76: G = __r_arr[6];
+                let __v_77: G = __r_arr[7];
+                let __v_78: G = __r_arr[8];
+                let __v_79: G = __r_arr[9];
+                let __v_80: G = __r_arr[10];
+                let __v_81: G = __r_arr[11];
+                let __v_82: G = __r_arr[12];
+                let __v_83: G = __r_arr[13];
+                let __v_84: G = __r_arr[14];
+                let __v_85: G = __r_arr[15];
+                let __v_86: G = __r_arr[16];
+                let __v_87: G = __r_arr[17];
+                let __v_88: G = __r_arr[18];
+                let __v_89: G = __r_arr[19];
+                let __v_90: G = __r_arr[20];
+                let __v_91: G = __r_arr[21];
+                let __v_92: G = __r_arr[22];
+                let __v_93: G = __r_arr[23];
+                let __v_94: G = __r_arr[24];
+                let __v_95: G = __r_arr[25];
+                let __v_96: G = __r_arr[26];
+                let __v_97: G = __r_arr[27];
+                let __v_98: G = __r_arr[28];
+                let __v_99: G = __r_arr[29];
+                let __v_100: G = __r_arr[30];
+                let __v_101: G = __r_arr[31];
+                let __ret: [G; OUT_61] = [__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];
                 record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_35.as_canonical_u64()));
               },
             }
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
     }
   })
 }
@@ -3030,45 +2780,40 @@ fn aiur_fn_62(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_7: G = __loaded[0];
-    let __v_8: G = __loaded[1];
-    let __v_9: G = __loaded[2];
-    match __v_7.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_62] = [__v_10];
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_62] = [__v_7];
         record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        match __v_2.as_canonical_u64() {
-          63u64 => {
-            let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; 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_12: G = __r_arr[0];
-            let __ret: [G; OUT_62] = [__v_12];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = { let __values: [G; 2] = [__v_7, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        match __v_2.as_canonical_u64() {
+          63u64 => {
+            let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_8, __v_9, __v_3, __v_4, __v_5, __v_6]; 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_10: G = __r_arr[0];
+            let __ret: [G; OUT_62] = [__v_10];
             record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
+            let __v_10: G = G::from_u64(1);
+            let __v_11: G = (__v_2 + __v_10);
             let __v_12: G = G::from_u64(1);
-            let __v_13: G = (__v_2 + __v_12);
-            let __v_14: G = G::from_u64(1);
-            let __v_15: G = (__v_3 + __v_14);
-            let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; 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_16: G = __r_arr[0];
-            let __ret: [G; OUT_62] = [__v_16];
+            let __v_13: G = (__v_3 + __v_12);
+            let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_8, __v_9, __v_11, __v_13, __v_4, __v_5, __v_6]; 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_14: G = __r_arr[0];
+            let __ret: [G; OUT_62] = [__v_14];
             record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-      },
     }
   })
 }
@@ -3084,712 +2829,1096 @@ fn aiur_fn_63(
 ) -> Result<[G; OUT_63], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_4: G = __loaded[0];
-        let __v_5: G = __loaded[1];
-        let __v_6: G = __loaded[2];
-        match __v_4.as_canonical_u64() {
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(1);
+        if (__v_1 != __v_2) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_63] = [__v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1, __v_1];
+        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        match __v_2.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_7: G = __loaded[0];
-            let __v_8: G = __loaded[1];
-            let __v_9: G = __loaded[2];
-            match __v_7.as_canonical_u64() {
+            let __v_3: G = G::from_u64(0);
+            let __v_4: G = G::from_u64(1);
+            if (__v_3 != __v_4) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_63] = [__v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3];
+            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_3: G = __loaded[0];
+            let __v_4: G = __loaded[1];
+            match __v_4.as_canonical_u64() {
               0u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                let __v_10: G = __loaded[0];
-                let __v_11: G = __loaded[1];
-                let __v_12: G = __loaded[2];
-                match __v_10.as_canonical_u64() {
+                let __v_5: G = G::from_u64(0);
+                let __v_6: G = G::from_u64(1);
+                if (__v_5 != __v_6) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                }
+                let __ret: [G; OUT_63] = [__v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5];
+                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                let __v_5: G = __loaded[0];
+                let __v_6: G = __loaded[1];
+                match __v_6.as_canonical_u64() {
                   0u64 => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                    let __v_13: G = __loaded[0];
-                    let __v_14: G = __loaded[1];
-                    let __v_15: G = __loaded[2];
-                    match __v_13.as_canonical_u64() {
+                    let __v_7: G = G::from_u64(0);
+                    let __v_8: G = G::from_u64(1);
+                    if (__v_7 != __v_8) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                    }
+                    let __ret: [G; OUT_63] = [__v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7];
+                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                    let __v_7: G = __loaded[0];
+                    let __v_8: G = __loaded[1];
+                    match __v_8.as_canonical_u64() {
                       0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                        let __v_16: G = __loaded[0];
-                        let __v_17: G = __loaded[1];
-                        let __v_18: G = __loaded[2];
-                        match __v_16.as_canonical_u64() {
+                        let __v_9: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                        }
+                        let __ret: [G; OUT_63] = [__v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9];
+                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                        let __v_9: G = __loaded[0];
+                        let __v_10: G = __loaded[1];
+                        match __v_10.as_canonical_u64() {
                           0u64 => {
-                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                            let __v_19: G = __loaded[0];
-                            let __v_20: G = __loaded[1];
-                            let __v_21: G = __loaded[2];
-                            match __v_19.as_canonical_u64() {
+                            let __v_11: G = G::from_u64(0);
+                            let __v_12: G = G::from_u64(1);
+                            if (__v_11 != __v_12) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                            }
+                            let __ret: [G; OUT_63] = [__v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11];
+                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                            let __v_11: G = __loaded[0];
+                            let __v_12: G = __loaded[1];
+                            match __v_12.as_canonical_u64() {
                               0u64 => {
-                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                let __v_22: G = __loaded[0];
-                                let __v_23: G = __loaded[1];
-                                let __v_24: G = __loaded[2];
-                                match __v_22.as_canonical_u64() {
+                                let __v_13: G = G::from_u64(0);
+                                let __v_14: G = G::from_u64(1);
+                                if (__v_13 != __v_14) {
+                                  return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                }
+                                let __ret: [G; OUT_63] = [__v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13];
+                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                let __v_13: G = __loaded[0];
+                                let __v_14: G = __loaded[1];
+                                match __v_14.as_canonical_u64() {
                                   0u64 => {
-                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                    let __v_25: G = __loaded[0];
-                                    let __v_26: G = __loaded[1];
-                                    let __v_27: G = __loaded[2];
-                                    match __v_25.as_canonical_u64() {
+                                    let __v_15: G = G::from_u64(0);
+                                    let __v_16: G = G::from_u64(1);
+                                    if (__v_15 != __v_16) {
+                                      return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                    }
+                                    let __ret: [G; OUT_63] = [__v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15];
+                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                    let __v_15: G = __loaded[0];
+                                    let __v_16: G = __loaded[1];
+                                    match __v_16.as_canonical_u64() {
                                       0u64 => {
-                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                        let __v_28: G = __loaded[0];
-                                        let __v_29: G = __loaded[1];
-                                        let __v_30: G = __loaded[2];
-                                        match __v_28.as_canonical_u64() {
+                                        let __v_17: G = G::from_u64(0);
+                                        let __v_18: G = G::from_u64(1);
+                                        if (__v_17 != __v_18) {
+                                          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                        }
+                                        let __ret: [G; OUT_63] = [__v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
+                                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                        let __v_17: G = __loaded[0];
+                                        let __v_18: G = __loaded[1];
+                                        match __v_18.as_canonical_u64() {
                                           0u64 => {
-                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                            let __v_31: G = __loaded[0];
-                                            let __v_32: G = __loaded[1];
-                                            let __v_33: G = __loaded[2];
-                                            match __v_31.as_canonical_u64() {
+                                            let __v_19: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                            }
+                                            let __ret: [G; OUT_63] = [__v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19];
+                                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            return Ok(__ret);
+                                          },
+                                          _ => {
+                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                            let __v_19: G = __loaded[0];
+                                            let __v_20: G = __loaded[1];
+                                            match __v_20.as_canonical_u64() {
                                               0u64 => {
-                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                let __v_34: G = __loaded[0];
-                                                let __v_35: G = __loaded[1];
-                                                let __v_36: G = __loaded[2];
-                                                match __v_34.as_canonical_u64() {
+                                                let __v_21: G = G::from_u64(0);
+                                                let __v_22: G = G::from_u64(1);
+                                                if (__v_21 != __v_22) {
+                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                }
+                                                let __ret: [G; OUT_63] = [__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_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_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
+                                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                return Ok(__ret);
+                                              },
+                                              _ => {
+                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                let __v_21: G = __loaded[0];
+                                                let __v_22: G = __loaded[1];
+                                                match __v_22.as_canonical_u64() {
                                                   0u64 => {
-                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                    let __v_37: G = __loaded[0];
-                                                    let __v_38: G = __loaded[1];
-                                                    let __v_39: G = __loaded[2];
-                                                    match __v_37.as_canonical_u64() {
+                                                    let __v_23: G = G::from_u64(0);
+                                                    let __v_24: G = G::from_u64(1);
+                                                    if (__v_23 != __v_24) {
+                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                    }
+                                                    let __ret: [G; OUT_63] = [__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, __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, __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, __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, __v_23, __v_23, __v_23, __v_23];
+                                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    return Ok(__ret);
+                                                  },
+                                                  _ => {
+                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                    let __v_23: G = __loaded[0];
+                                                    let __v_24: G = __loaded[1];
+                                                    match __v_24.as_canonical_u64() {
                                                       0u64 => {
-                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                        let __v_40: G = __loaded[0];
-                                                        let __v_41: G = __loaded[1];
-                                                        let __v_42: G = __loaded[2];
-                                                        match __v_40.as_canonical_u64() {
+                                                        let __v_25: G = G::from_u64(0);
+                                                        let __v_26: G = G::from_u64(1);
+                                                        if (__v_25 != __v_26) {
+                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                        }
+                                                        let __ret: [G; OUT_63] = [__v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25];
+                                                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                        return Ok(__ret);
+                                                      },
+                                                      _ => {
+                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                        let __v_25: G = __loaded[0];
+                                                        let __v_26: G = __loaded[1];
+                                                        match __v_26.as_canonical_u64() {
                                                           0u64 => {
-                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                            let __v_43: G = __loaded[0];
-                                                            let __v_44: G = __loaded[1];
-                                                            let __v_45: G = __loaded[2];
-                                                            match __v_43.as_canonical_u64() {
+                                                            let __v_27: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                            }
+                                                            let __ret: [G; OUT_63] = [__v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27];
+                                                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            return Ok(__ret);
+                                                          },
+                                                          _ => {
+                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                            let __v_27: G = __loaded[0];
+                                                            let __v_28: G = __loaded[1];
+                                                            match __v_28.as_canonical_u64() {
                                                               0u64 => {
-                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                let __v_46: G = __loaded[0];
-                                                                let __v_47: G = __loaded[1];
-                                                                let __v_48: G = __loaded[2];
-                                                                match __v_46.as_canonical_u64() {
+                                                                let __v_29: G = G::from_u64(0);
+                                                                let __v_30: G = G::from_u64(1);
+                                                                if (__v_29 != __v_30) {
+                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                }
+                                                                let __ret: [G; OUT_63] = [__v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29];
+                                                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                return Ok(__ret);
+                                                              },
+                                                              _ => {
+                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                let __v_29: G = __loaded[0];
+                                                                let __v_30: G = __loaded[1];
+                                                                match __v_30.as_canonical_u64() {
                                                                   0u64 => {
-                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                    let __v_49: G = __loaded[0];
-                                                                    let __v_50: G = __loaded[1];
-                                                                    let __v_51: G = __loaded[2];
-                                                                    match __v_49.as_canonical_u64() {
+                                                                    let __v_31: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                    }
+                                                                    let __ret: [G; OUT_63] = [__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_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31];
+                                                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                    return Ok(__ret);
+                                                                  },
+                                                                  _ => {
+                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                    let __v_31: G = __loaded[0];
+                                                                    let __v_32: G = __loaded[1];
+                                                                    match __v_32.as_canonical_u64() {
                                                                       0u64 => {
-                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                        let __v_52: G = __loaded[0];
-                                                                        let __v_53: G = __loaded[1];
-                                                                        let __v_54: G = __loaded[2];
-                                                                        match __v_52.as_canonical_u64() {
+                                                                        let __v_33: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                        }
+                                                                        let __ret: [G; OUT_63] = [__v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33, __v_33];
+                                                                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                        return Ok(__ret);
+                                                                      },
+                                                                      _ => {
+                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_32.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                        let __v_33: G = __loaded[0];
+                                                                        let __v_34: G = __loaded[1];
+                                                                        match __v_34.as_canonical_u64() {
                                                                           0u64 => {
-                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                            let __v_55: G = __loaded[0];
-                                                                            let __v_56: G = __loaded[1];
-                                                                            let __v_57: G = __loaded[2];
-                                                                            match __v_55.as_canonical_u64() {
+                                                                            let __v_35: G = G::from_u64(0);
+                                                                            let __v_36: G = G::from_u64(1);
+                                                                            if (__v_35 != __v_36) {
+                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                            }
+                                                                            let __ret: [G; OUT_63] = [__v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35, __v_35];
+                                                                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                            return Ok(__ret);
+                                                                          },
+                                                                          _ => {
+                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                            let __v_35: G = __loaded[0];
+                                                                            let __v_36: G = __loaded[1];
+                                                                            match __v_36.as_canonical_u64() {
                                                                               0u64 => {
-                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                let __v_58: G = __loaded[0];
-                                                                                let __v_59: G = __loaded[1];
-                                                                                let __v_60: G = __loaded[2];
-                                                                                match __v_58.as_canonical_u64() {
+                                                                                let __v_37: G = G::from_u64(0);
+                                                                                let __v_38: G = G::from_u64(1);
+                                                                                if (__v_37 != __v_38) {
+                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_38.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                }
+                                                                                let __ret: [G; OUT_63] = [__v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
+                                                                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                return Ok(__ret);
+                                                                              },
+                                                                              _ => {
+                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                let __v_37: G = __loaded[0];
+                                                                                let __v_38: G = __loaded[1];
+                                                                                match __v_38.as_canonical_u64() {
                                                                                   0u64 => {
-                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                    let __v_61: G = __loaded[0];
-                                                                                    let __v_62: G = __loaded[1];
-                                                                                    let __v_63: G = __loaded[2];
-                                                                                    match __v_61.as_canonical_u64() {
+                                                                                    let __v_39: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                    }
+                                                                                    let __ret: [G; OUT_63] = [__v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39];
+                                                                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                    return Ok(__ret);
+                                                                                  },
+                                                                                  _ => {
+                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_38.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                    let __v_39: G = __loaded[0];
+                                                                                    let __v_40: G = __loaded[1];
+                                                                                    match __v_40.as_canonical_u64() {
                                                                                       0u64 => {
-                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                        let __v_64: G = __loaded[0];
-                                                                                        let __v_65: G = __loaded[1];
-                                                                                        let __v_66: G = __loaded[2];
-                                                                                        match __v_64.as_canonical_u64() {
+                                                                                        let __v_41: G = G::from_u64(0);
+                                                                                        let __v_42: G = G::from_u64(1);
+                                                                                        if (__v_41 != __v_42) {
+                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                        }
+                                                                                        let __ret: [G; OUT_63] = [__v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41];
+                                                                                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                        return Ok(__ret);
+                                                                                      },
+                                                                                      _ => {
+                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                        let __v_41: G = __loaded[0];
+                                                                                        let __v_42: G = __loaded[1];
+                                                                                        match __v_42.as_canonical_u64() {
                                                                                           0u64 => {
-                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                            let __v_67: G = __loaded[0];
-                                                                                            let __v_68: G = __loaded[1];
-                                                                                            let __v_69: G = __loaded[2];
-                                                                                            match __v_67.as_canonical_u64() {
+                                                                                            let __v_43: G = G::from_u64(0);
+                                                                                            let __v_44: G = G::from_u64(1);
+                                                                                            if (__v_43 != __v_44) {
+                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                            }
+                                                                                            let __ret: [G; OUT_63] = [__v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43, __v_43];
+                                                                                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                            return Ok(__ret);
+                                                                                          },
+                                                                                          _ => {
+                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                            let __v_43: G = __loaded[0];
+                                                                                            let __v_44: G = __loaded[1];
+                                                                                            match __v_44.as_canonical_u64() {
                                                                                               0u64 => {
-                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                let __v_70: G = __loaded[0];
-                                                                                                let __v_71: G = __loaded[1];
-                                                                                                let __v_72: G = __loaded[2];
-                                                                                                match __v_70.as_canonical_u64() {
+                                                                                                let __v_45: G = G::from_u64(0);
+                                                                                                let __v_46: G = G::from_u64(1);
+                                                                                                if (__v_45 != __v_46) {
+                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                }
+                                                                                                let __ret: [G; OUT_63] = [__v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45];
+                                                                                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                return Ok(__ret);
+                                                                                              },
+                                                                                              _ => {
+                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_44.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                let __v_45: G = __loaded[0];
+                                                                                                let __v_46: G = __loaded[1];
+                                                                                                match __v_46.as_canonical_u64() {
                                                                                                   0u64 => {
-                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                    let __v_73: G = __loaded[0];
-                                                                                                    let __v_74: G = __loaded[1];
-                                                                                                    let __v_75: G = __loaded[2];
-                                                                                                    match __v_73.as_canonical_u64() {
+                                                                                                    let __v_47: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                    }
+                                                                                                    let __ret: [G; OUT_63] = [__v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47];
+                                                                                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                    return Ok(__ret);
+                                                                                                  },
+                                                                                                  _ => {
+                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_46.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                    let __v_47: G = __loaded[0];
+                                                                                                    let __v_48: G = __loaded[1];
+                                                                                                    match __v_48.as_canonical_u64() {
                                                                                                       0u64 => {
-                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                        let __v_76: G = __loaded[0];
-                                                                                                        let __v_77: G = __loaded[1];
-                                                                                                        let __v_78: G = __loaded[2];
-                                                                                                        match __v_76.as_canonical_u64() {
+                                                                                                        let __v_49: G = G::from_u64(0);
+                                                                                                        let __v_50: G = G::from_u64(1);
+                                                                                                        if (__v_49 != __v_50) {
+                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                        }
+                                                                                                        let __ret: [G; OUT_63] = [__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, __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];
+                                                                                                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                        return Ok(__ret);
+                                                                                                      },
+                                                                                                      _ => {
+                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                        let __v_49: G = __loaded[0];
+                                                                                                        let __v_50: G = __loaded[1];
+                                                                                                        match __v_50.as_canonical_u64() {
                                                                                                           0u64 => {
-                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                            let __v_79: G = __loaded[0];
-                                                                                                            let __v_80: G = __loaded[1];
-                                                                                                            let __v_81: G = __loaded[2];
-                                                                                                            match __v_79.as_canonical_u64() {
+                                                                                                            let __v_51: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                            }
+                                                                                                            let __ret: [G; OUT_63] = [__v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51];
+                                                                                                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                            return Ok(__ret);
+                                                                                                          },
+                                                                                                          _ => {
+                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                            let __v_51: G = __loaded[0];
+                                                                                                            let __v_52: G = __loaded[1];
+                                                                                                            match __v_52.as_canonical_u64() {
                                                                                                               0u64 => {
-                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                let __v_82: G = __loaded[0];
-                                                                                                                let __v_83: G = __loaded[1];
-                                                                                                                let __v_84: G = __loaded[2];
-                                                                                                                match __v_82.as_canonical_u64() {
+                                                                                                                let __v_53: G = G::from_u64(0);
+                                                                                                                let __v_54: G = G::from_u64(1);
+                                                                                                                if (__v_53 != __v_54) {
+                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                }
+                                                                                                                let __ret: [G; OUT_63] = [__v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53];
+                                                                                                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                return Ok(__ret);
+                                                                                                              },
+                                                                                                              _ => {
+                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_52.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                let __v_53: G = __loaded[0];
+                                                                                                                let __v_54: G = __loaded[1];
+                                                                                                                match __v_54.as_canonical_u64() {
                                                                                                                   0u64 => {
-                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                    let __v_85: G = __loaded[0];
-                                                                                                                    let __v_86: G = __loaded[1];
-                                                                                                                    let __v_87: G = __loaded[2];
-                                                                                                                    match __v_85.as_canonical_u64() {
+                                                                                                                    let __v_55: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                    }
+                                                                                                                    let __ret: [G; OUT_63] = [__v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55, __v_55];
+                                                                                                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                    return Ok(__ret);
+                                                                                                                  },
+                                                                                                                  _ => {
+                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                    let __v_55: G = __loaded[0];
+                                                                                                                    let __v_56: G = __loaded[1];
+                                                                                                                    match __v_56.as_canonical_u64() {
                                                                                                                       0u64 => {
-                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                        let __v_88: G = __loaded[0];
-                                                                                                                        let __v_89: G = __loaded[1];
-                                                                                                                        let __v_90: G = __loaded[2];
-                                                                                                                        match __v_88.as_canonical_u64() {
+                                                                                                                        let __v_57: G = G::from_u64(0);
+                                                                                                                        let __v_58: G = G::from_u64(1);
+                                                                                                                        if (__v_57 != __v_58) {
+                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                        }
+                                                                                                                        let __ret: [G; OUT_63] = [__v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57];
+                                                                                                                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                        return Ok(__ret);
+                                                                                                                      },
+                                                                                                                      _ => {
+                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                        let __v_57: G = __loaded[0];
+                                                                                                                        let __v_58: G = __loaded[1];
+                                                                                                                        match __v_58.as_canonical_u64() {
                                                                                                                           0u64 => {
-                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                            let __v_91: G = __loaded[0];
-                                                                                                                            let __v_92: G = __loaded[1];
-                                                                                                                            let __v_93: G = __loaded[2];
-                                                                                                                            match __v_91.as_canonical_u64() {
+                                                                                                                            let __v_59: G = G::from_u64(0);
+                                                                                                                            let __v_60: G = G::from_u64(1);
+                                                                                                                            if (__v_59 != __v_60) {
+                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                            }
+                                                                                                                            let __ret: [G; OUT_63] = [__v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59];
+                                                                                                                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                            return Ok(__ret);
+                                                                                                                          },
+                                                                                                                          _ => {
+                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_58.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                            let __v_59: G = __loaded[0];
+                                                                                                                            let __v_60: G = __loaded[1];
+                                                                                                                            match __v_60.as_canonical_u64() {
                                                                                                                               0u64 => {
-                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                let __v_94: G = __loaded[0];
-                                                                                                                                let __v_95: G = __loaded[1];
-                                                                                                                                let __v_96: G = __loaded[2];
-                                                                                                                                match __v_94.as_canonical_u64() {
+                                                                                                                                let __v_61: G = G::from_u64(0);
+                                                                                                                                let __v_62: G = G::from_u64(1);
+                                                                                                                                if (__v_61 != __v_62) {
+                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                }
+                                                                                                                                let __ret: [G; OUT_63] = [__v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61];
+                                                                                                                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                return Ok(__ret);
+                                                                                                                              },
+                                                                                                                              _ => {
+                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                let __v_61: G = __loaded[0];
+                                                                                                                                let __v_62: G = __loaded[1];
+                                                                                                                                match __v_62.as_canonical_u64() {
                                                                                                                                   0u64 => {
-                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                    let __v_97: G = __loaded[0];
-                                                                                                                                    let __v_98: G = __loaded[1];
-                                                                                                                                    let __v_99: G = __loaded[2];
-                                                                                                                                    match __v_97.as_canonical_u64() {
+                                                                                                                                    let __v_63: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                    }
+                                                                                                                                    let __ret: [G; OUT_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, __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, __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, __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];
+                                                                                                                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                    return Ok(__ret);
+                                                                                                                                  },
+                                                                                                                                  _ => {
+                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_62.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                    let __v_63: G = __loaded[0];
+                                                                                                                                    let __v_64: G = __loaded[1];
+                                                                                                                                    match __v_64.as_canonical_u64() {
                                                                                                                                       0u64 => {
-                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                        let __v_100: G = __loaded[0];
-                                                                                                                                        let __v_101: G = __loaded[1];
-                                                                                                                                        let __v_102: G = __loaded[2];
-                                                                                                                                        match __v_100.as_canonical_u64() {
+                                                                                                                                        let __v_65: G = G::from_u64(0);
+                                                                                                                                        let __v_66: G = G::from_u64(1);
+                                                                                                                                        if (__v_65 != __v_66) {
+                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                        }
+                                                                                                                                        let __ret: [G; OUT_63] = [__v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65, __v_65];
+                                                                                                                                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                        return Ok(__ret);
+                                                                                                                                      },
+                                                                                                                                      _ => {
+                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_64.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                        let __v_65: G = __loaded[0];
+                                                                                                                                        let __v_66: G = __loaded[1];
+                                                                                                                                        match __v_66.as_canonical_u64() {
                                                                                                                                           0u64 => {
-                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                            let __v_103: G = __loaded[0];
-                                                                                                                                            let __v_104: G = __loaded[1];
-                                                                                                                                            let __v_105: G = __loaded[2];
-                                                                                                                                            match __v_103.as_canonical_u64() {
+                                                                                                                                            let __v_67: G = G::from_u64(0);
+                                                                                                                                            let __v_68: G = G::from_u64(1);
+                                                                                                                                            if (__v_67 != __v_68) {
+                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_68.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                            }
+                                                                                                                                            let __ret: [G; OUT_63] = [__v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67, __v_67];
+                                                                                                                                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                            return Ok(__ret);
+                                                                                                                                          },
+                                                                                                                                          _ => {
+                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                            let __v_67: G = __loaded[0];
+                                                                                                                                            let __v_68: G = __loaded[1];
+                                                                                                                                            match __v_68.as_canonical_u64() {
                                                                                                                                               0u64 => {
-                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                let __v_106: G = __loaded[0];
-                                                                                                                                                let __v_107: G = __loaded[1];
-                                                                                                                                                let __v_108: G = __loaded[2];
-                                                                                                                                                match __v_106.as_canonical_u64() {
+                                                                                                                                                let __v_69: G = G::from_u64(0);
+                                                                                                                                                let __v_70: G = G::from_u64(1);
+                                                                                                                                                if (__v_69 != __v_70) {
+                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                }
+                                                                                                                                                let __ret: [G; OUT_63] = [__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, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69];
+                                                                                                                                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                return Ok(__ret);
+                                                                                                                                              },
+                                                                                                                                              _ => {
+                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_68.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                let __v_69: G = __loaded[0];
+                                                                                                                                                let __v_70: G = __loaded[1];
+                                                                                                                                                match __v_70.as_canonical_u64() {
                                                                                                                                                   0u64 => {
-                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                    let __v_109: G = __loaded[0];
-                                                                                                                                                    let __v_110: G = __loaded[1];
-                                                                                                                                                    let __v_111: G = __loaded[2];
-                                                                                                                                                    match __v_109.as_canonical_u64() {
+                                                                                                                                                    let __v_71: G = G::from_u64(0);
+                                                                                                                                                    let __v_72: G = G::from_u64(1);
+                                                                                                                                                    if (__v_71 != __v_72) {
+                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_72.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                    }
+                                                                                                                                                    let __ret: [G; OUT_63] = [__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, __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];
+                                                                                                                                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                  },
+                                                                                                                                                  _ => {
+                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                    let __v_71: G = __loaded[0];
+                                                                                                                                                    let __v_72: G = __loaded[1];
+                                                                                                                                                    match __v_72.as_canonical_u64() {
                                                                                                                                                       0u64 => {
-                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                        let __v_112: G = __loaded[0];
-                                                                                                                                                        let __v_113: G = __loaded[1];
-                                                                                                                                                        let __v_114: G = __loaded[2];
-                                                                                                                                                        match __v_112.as_canonical_u64() {
+                                                                                                                                                        let __v_73: G = G::from_u64(0);
+                                                                                                                                                        let __v_74: G = G::from_u64(1);
+                                                                                                                                                        if (__v_73 != __v_74) {
+                                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_74.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                        }
+                                                                                                                                                        let __ret: [G; OUT_63] = [__v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73, __v_73];
+                                                                                                                                                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                        return Ok(__ret);
+                                                                                                                                                      },
+                                                                                                                                                      _ => {
+                                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                        let __v_73: G = __loaded[0];
+                                                                                                                                                        let __v_74: G = __loaded[1];
+                                                                                                                                                        match __v_74.as_canonical_u64() {
                                                                                                                                                           0u64 => {
-                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                            let __v_115: G = __loaded[0];
-                                                                                                                                                            let __v_116: G = __loaded[1];
-                                                                                                                                                            let __v_117: G = __loaded[2];
-                                                                                                                                                            match __v_115.as_canonical_u64() {
+                                                                                                                                                            let __v_75: G = G::from_u64(0);
+                                                                                                                                                            let __v_76: G = G::from_u64(1);
+                                                                                                                                                            if (__v_75 != __v_76) {
+                                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_76.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                            }
+                                                                                                                                                            let __ret: [G; OUT_63] = [__v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75, __v_75];
+                                                                                                                                                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                            return Ok(__ret);
+                                                                                                                                                          },
+                                                                                                                                                          _ => {
+                                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_74.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                            let __v_75: G = __loaded[0];
+                                                                                                                                                            let __v_76: G = __loaded[1];
+                                                                                                                                                            match __v_76.as_canonical_u64() {
                                                                                                                                                               0u64 => {
-                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                let __v_118: G = __loaded[0];
-                                                                                                                                                                let __v_119: G = __loaded[1];
-                                                                                                                                                                let __v_120: G = __loaded[2];
-                                                                                                                                                                match __v_118.as_canonical_u64() {
+                                                                                                                                                                let __v_77: G = G::from_u64(0);
+                                                                                                                                                                let __v_78: G = G::from_u64(1);
+                                                                                                                                                                if (__v_77 != __v_78) {
+                                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_78.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                }
+                                                                                                                                                                let __ret: [G; OUT_63] = [__v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77, __v_77];
+                                                                                                                                                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                return Ok(__ret);
+                                                                                                                                                              },
+                                                                                                                                                              _ => {
+                                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_76.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                let __v_77: G = __loaded[0];
+                                                                                                                                                                let __v_78: G = __loaded[1];
+                                                                                                                                                                match __v_78.as_canonical_u64() {
                                                                                                                                                                   0u64 => {
-                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                    let __v_121: G = __loaded[0];
-                                                                                                                                                                    let __v_122: G = __loaded[1];
-                                                                                                                                                                    let __v_123: G = __loaded[2];
-                                                                                                                                                                    match __v_121.as_canonical_u64() {
+                                                                                                                                                                    let __v_79: G = G::from_u64(0);
+                                                                                                                                                                    let __v_80: G = G::from_u64(1);
+                                                                                                                                                                    if (__v_79 != __v_80) {
+                                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_80.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                    }
+                                                                                                                                                                    let __ret: [G; OUT_63] = [__v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79];
+                                                                                                                                                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                  },
+                                                                                                                                                                  _ => {
+                                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                    let __v_79: G = __loaded[0];
+                                                                                                                                                                    let __v_80: G = __loaded[1];
+                                                                                                                                                                    match __v_80.as_canonical_u64() {
                                                                                                                                                                       0u64 => {
-                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                        let __v_124: G = __loaded[0];
-                                                                                                                                                                        let __v_125: G = __loaded[1];
-                                                                                                                                                                        let __v_126: G = __loaded[2];
-                                                                                                                                                                        match __v_124.as_canonical_u64() {
+                                                                                                                                                                        let __v_81: G = G::from_u64(0);
+                                                                                                                                                                        let __v_82: G = G::from_u64(1);
+                                                                                                                                                                        if (__v_81 != __v_82) {
+                                                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_82.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                        }
+                                                                                                                                                                        let __ret: [G; OUT_63] = [__v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81];
+                                                                                                                                                                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                        return Ok(__ret);
+                                                                                                                                                                      },
+                                                                                                                                                                      _ => {
+                                                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_80.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                        let __v_81: G = __loaded[0];
+                                                                                                                                                                        let __v_82: G = __loaded[1];
+                                                                                                                                                                        match __v_82.as_canonical_u64() {
                                                                                                                                                                           0u64 => {
-                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                            let __v_127: G = __loaded[0];
-                                                                                                                                                                            let __v_128: G = __loaded[1];
-                                                                                                                                                                            let __v_129: G = __loaded[2];
-                                                                                                                                                                            match __v_127.as_canonical_u64() {
+                                                                                                                                                                            let __v_83: G = G::from_u64(0);
+                                                                                                                                                                            let __v_84: G = G::from_u64(1);
+                                                                                                                                                                            if (__v_83 != __v_84) {
+                                                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_83.as_canonical_u64(), rhs: __v_84.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                            }
+                                                                                                                                                                            let __ret: [G; OUT_63] = [__v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83, __v_83];
+                                                                                                                                                                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                            return Ok(__ret);
+                                                                                                                                                                          },
+                                                                                                                                                                          _ => {
+                                                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_82.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                            let __v_83: G = __loaded[0];
+                                                                                                                                                                            let __v_84: G = __loaded[1];
+                                                                                                                                                                            match __v_84.as_canonical_u64() {
                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                let __v_130: G = __loaded[0];
-                                                                                                                                                                                let __v_131: G = __loaded[1];
-                                                                                                                                                                                let __v_132: G = __loaded[2];
-                                                                                                                                                                                match __v_130.as_canonical_u64() {
+                                                                                                                                                                                let __v_85: G = G::from_u64(0);
+                                                                                                                                                                                let __v_86: G = G::from_u64(1);
+                                                                                                                                                                                if (__v_85 != __v_86) {
+                                                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_86.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                }
+                                                                                                                                                                                let __ret: [G; OUT_63] = [__v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85, __v_85];
+                                                                                                                                                                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                return Ok(__ret);
+                                                                                                                                                                              },
+                                                                                                                                                                              _ => {
+                                                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                let __v_85: G = __loaded[0];
+                                                                                                                                                                                let __v_86: G = __loaded[1];
+                                                                                                                                                                                match __v_86.as_canonical_u64() {
                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                    let __v_133: G = __loaded[0];
-                                                                                                                                                                                    let __v_134: G = __loaded[1];
-                                                                                                                                                                                    let __v_135: G = __loaded[2];
-                                                                                                                                                                                    match __v_133.as_canonical_u64() {
+                                                                                                                                                                                    let __v_87: G = G::from_u64(0);
+                                                                                                                                                                                    let __v_88: G = G::from_u64(1);
+                                                                                                                                                                                    if (__v_87 != __v_88) {
+                                                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                    }
+                                                                                                                                                                                    let __ret: [G; OUT_63] = [__v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87, __v_87];
+                                                                                                                                                                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                                  },
+                                                                                                                                                                                  _ => {
+                                                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                    let __v_87: G = __loaded[0];
+                                                                                                                                                                                    let __v_88: G = __loaded[1];
+                                                                                                                                                                                    match __v_88.as_canonical_u64() {
                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                        let __v_136: G = __loaded[0];
-                                                                                                                                                                                        let __v_137: G = __loaded[1];
-                                                                                                                                                                                        let __v_138: G = __loaded[2];
-                                                                                                                                                                                        match __v_136.as_canonical_u64() {
+                                                                                                                                                                                        let __v_89: G = G::from_u64(0);
+                                                                                                                                                                                        let __v_90: G = G::from_u64(1);
+                                                                                                                                                                                        if (__v_89 != __v_90) {
+                                                                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_90.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                        }
+                                                                                                                                                                                        let __ret: [G; OUT_63] = [__v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89, __v_89];
+                                                                                                                                                                                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                        return Ok(__ret);
+                                                                                                                                                                                      },
+                                                                                                                                                                                      _ => {
+                                                                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_88.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                        let __v_89: G = __loaded[0];
+                                                                                                                                                                                        let __v_90: G = __loaded[1];
+                                                                                                                                                                                        match __v_90.as_canonical_u64() {
                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                            let __v_139: G = __loaded[0];
-                                                                                                                                                                                            let __v_140: G = __loaded[1];
-                                                                                                                                                                                            let __v_141: G = __loaded[2];
-                                                                                                                                                                                            match __v_139.as_canonical_u64() {
+                                                                                                                                                                                            let __v_91: G = G::from_u64(0);
+                                                                                                                                                                                            let __v_92: G = G::from_u64(1);
+                                                                                                                                                                                            if (__v_91 != __v_92) {
+                                                                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_91.as_canonical_u64(), rhs: __v_92.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                            }
+                                                                                                                                                                                            let __ret: [G; OUT_63] = [__v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91, __v_91];
+                                                                                                                                                                                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                            return Ok(__ret);
+                                                                                                                                                                                          },
+                                                                                                                                                                                          _ => {
+                                                                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                            let __v_91: G = __loaded[0];
+                                                                                                                                                                                            let __v_92: G = __loaded[1];
+                                                                                                                                                                                            match __v_92.as_canonical_u64() {
                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                let __v_142: G = __loaded[0];
-                                                                                                                                                                                                let __v_143: G = __loaded[1];
-                                                                                                                                                                                                let __v_144: G = __loaded[2];
-                                                                                                                                                                                                match __v_142.as_canonical_u64() {
+                                                                                                                                                                                                let __v_93: G = G::from_u64(0);
+                                                                                                                                                                                                let __v_94: G = G::from_u64(1);
+                                                                                                                                                                                                if (__v_93 != __v_94) {
+                                                                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_94.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                }
+                                                                                                                                                                                                let __ret: [G; OUT_63] = [__v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93, __v_93];
+                                                                                                                                                                                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                return Ok(__ret);
+                                                                                                                                                                                              },
+                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                let __v_93: G = __loaded[0];
+                                                                                                                                                                                                let __v_94: G = __loaded[1];
+                                                                                                                                                                                                match __v_94.as_canonical_u64() {
                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                    let __v_145: G = __loaded[0];
-                                                                                                                                                                                                    let __v_146: G = __loaded[1];
-                                                                                                                                                                                                    let __v_147: G = __loaded[2];
-                                                                                                                                                                                                    match __v_145.as_canonical_u64() {
+                                                                                                                                                                                                    let __v_95: G = G::from_u64(0);
+                                                                                                                                                                                                    let __v_96: G = G::from_u64(1);
+                                                                                                                                                                                                    if (__v_95 != __v_96) {
+                                                                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_96.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                    }
+                                                                                                                                                                                                    let __ret: [G; OUT_63] = [__v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95, __v_95];
+                                                                                                                                                                                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                                                  },
+                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_94.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                    let __v_95: G = __loaded[0];
+                                                                                                                                                                                                    let __v_96: G = __loaded[1];
+                                                                                                                                                                                                    match __v_96.as_canonical_u64() {
                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                        let __v_148: G = __loaded[0];
-                                                                                                                                                                                                        let __v_149: G = __loaded[1];
-                                                                                                                                                                                                        let __v_150: G = __loaded[2];
-                                                                                                                                                                                                        match __v_148.as_canonical_u64() {
+                                                                                                                                                                                                        let __v_97: G = G::from_u64(0);
+                                                                                                                                                                                                        let __v_98: G = G::from_u64(1);
+                                                                                                                                                                                                        if (__v_97 != __v_98) {
+                                                                                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_98.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                        }
+                                                                                                                                                                                                        let __ret: [G; OUT_63] = [__v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97, __v_97];
+                                                                                                                                                                                                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                        return Ok(__ret);
+                                                                                                                                                                                                      },
+                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                        let __v_97: G = __loaded[0];
+                                                                                                                                                                                                        let __v_98: G = __loaded[1];
+                                                                                                                                                                                                        match __v_98.as_canonical_u64() {
                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                            let __v_151: G = __loaded[0];
-                                                                                                                                                                                                            let __v_152: G = __loaded[1];
-                                                                                                                                                                                                            let __v_153: G = __loaded[2];
-                                                                                                                                                                                                            match __v_151.as_canonical_u64() {
+                                                                                                                                                                                                            let __v_99: G = G::from_u64(0);
+                                                                                                                                                                                                            let __v_100: G = G::from_u64(1);
+                                                                                                                                                                                                            if (__v_99 != __v_100) {
+                                                                                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_100.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                            }
+                                                                                                                                                                                                            let __ret: [G; OUT_63] = [__v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99, __v_99];
+                                                                                                                                                                                                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                            return Ok(__ret);
+                                                                                                                                                                                                          },
+                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_98.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                            let __v_99: G = __loaded[0];
+                                                                                                                                                                                                            let __v_100: G = __loaded[1];
+                                                                                                                                                                                                            match __v_100.as_canonical_u64() {
                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                let __v_154: G = __loaded[0];
-                                                                                                                                                                                                                let __v_155: G = __loaded[1];
-                                                                                                                                                                                                                let __v_156: G = __loaded[2];
-                                                                                                                                                                                                                match __v_154.as_canonical_u64() {
+                                                                                                                                                                                                                let __v_101: G = G::from_u64(0);
+                                                                                                                                                                                                                let __v_102: G = G::from_u64(1);
+                                                                                                                                                                                                                if (__v_101 != __v_102) {
+                                                                                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_101.as_canonical_u64(), rhs: __v_102.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                }
+                                                                                                                                                                                                                let __ret: [G; OUT_63] = [__v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101, __v_101];
+                                                                                                                                                                                                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                return Ok(__ret);
+                                                                                                                                                                                                              },
+                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                let __v_101: G = __loaded[0];
+                                                                                                                                                                                                                let __v_102: G = __loaded[1];
+                                                                                                                                                                                                                match __v_102.as_canonical_u64() {
                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                    let __v_157: G = __loaded[0];
-                                                                                                                                                                                                                    let __v_158: G = __loaded[1];
-                                                                                                                                                                                                                    let __v_159: G = __loaded[2];
-                                                                                                                                                                                                                    match __v_157.as_canonical_u64() {
+                                                                                                                                                                                                                    let __v_103: G = G::from_u64(0);
+                                                                                                                                                                                                                    let __v_104: G = G::from_u64(1);
+                                                                                                                                                                                                                    if (__v_103 != __v_104) {
+                                                                                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_103.as_canonical_u64(), rhs: __v_104.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                    let __ret: [G; OUT_63] = [__v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103, __v_103];
+                                                                                                                                                                                                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                    let __v_103: G = __loaded[0];
+                                                                                                                                                                                                                    let __v_104: G = __loaded[1];
+                                                                                                                                                                                                                    match __v_104.as_canonical_u64() {
                                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                        let __v_160: G = __loaded[0];
-                                                                                                                                                                                                                        let __v_161: G = __loaded[1];
-                                                                                                                                                                                                                        let __v_162: G = __loaded[2];
-                                                                                                                                                                                                                        match __v_160.as_canonical_u64() {
+                                                                                                                                                                                                                        let __v_105: G = G::from_u64(0);
+                                                                                                                                                                                                                        let __v_106: G = G::from_u64(1);
+                                                                                                                                                                                                                        if (__v_105 != __v_106) {
+                                                                                                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_105.as_canonical_u64(), rhs: __v_106.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                        let __ret: [G; OUT_63] = [__v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105, __v_105];
+                                                                                                                                                                                                                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                        return Ok(__ret);
+                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_104.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                        let __v_105: G = __loaded[0];
+                                                                                                                                                                                                                        let __v_106: G = __loaded[1];
+                                                                                                                                                                                                                        match __v_106.as_canonical_u64() {
                                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                            let __v_163: G = __loaded[0];
-                                                                                                                                                                                                                            let __v_164: G = __loaded[1];
-                                                                                                                                                                                                                            let __v_165: G = __loaded[2];
-                                                                                                                                                                                                                            match __v_163.as_canonical_u64() {
+                                                                                                                                                                                                                            let __v_107: G = G::from_u64(0);
+                                                                                                                                                                                                                            let __v_108: G = G::from_u64(1);
+                                                                                                                                                                                                                            if (__v_107 != __v_108) {
+                                                                                                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_107.as_canonical_u64(), rhs: __v_108.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                            let __ret: [G; OUT_63] = [__v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107, __v_107];
+                                                                                                                                                                                                                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                            return Ok(__ret);
+                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_106.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                            let __v_107: G = __loaded[0];
+                                                                                                                                                                                                                            let __v_108: G = __loaded[1];
+                                                                                                                                                                                                                            match __v_108.as_canonical_u64() {
                                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                let __v_166: G = __loaded[0];
-                                                                                                                                                                                                                                let __v_167: G = __loaded[1];
-                                                                                                                                                                                                                                let __v_168: G = __loaded[2];
-                                                                                                                                                                                                                                match __v_166.as_canonical_u64() {
+                                                                                                                                                                                                                                let __v_109: G = G::from_u64(0);
+                                                                                                                                                                                                                                let __v_110: G = G::from_u64(1);
+                                                                                                                                                                                                                                if (__v_109 != __v_110) {
+                                                                                                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_109.as_canonical_u64(), rhs: __v_110.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                let __ret: [G; OUT_63] = [__v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109, __v_109];
+                                                                                                                                                                                                                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                return Ok(__ret);
+                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                let __v_109: G = __loaded[0];
+                                                                                                                                                                                                                                let __v_110: G = __loaded[1];
+                                                                                                                                                                                                                                match __v_110.as_canonical_u64() {
                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                    let __v_169: G = __loaded[0];
-                                                                                                                                                                                                                                    let __v_170: G = __loaded[1];
-                                                                                                                                                                                                                                    let __v_171: G = __loaded[2];
-                                                                                                                                                                                                                                    match __v_169.as_canonical_u64() {
+                                                                                                                                                                                                                                    let __v_111: G = G::from_u64(0);
+                                                                                                                                                                                                                                    let __v_112: G = G::from_u64(1);
+                                                                                                                                                                                                                                    if (__v_111 != __v_112) {
+                                                                                                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_111.as_canonical_u64(), rhs: __v_112.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                    let __ret: [G; OUT_63] = [__v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111, __v_111];
+                                                                                                                                                                                                                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_110.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                    let __v_111: G = __loaded[0];
+                                                                                                                                                                                                                                    let __v_112: G = __loaded[1];
+                                                                                                                                                                                                                                    match __v_112.as_canonical_u64() {
                                                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                        let __v_172: G = __loaded[0];
-                                                                                                                                                                                                                                        let __v_173: G = __loaded[1];
-                                                                                                                                                                                                                                        let __v_174: G = __loaded[2];
-                                                                                                                                                                                                                                        match __v_172.as_canonical_u64() {
+                                                                                                                                                                                                                                        let __v_113: G = G::from_u64(0);
+                                                                                                                                                                                                                                        let __v_114: G = G::from_u64(1);
+                                                                                                                                                                                                                                        if (__v_113 != __v_114) {
+                                                                                                                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_113.as_canonical_u64(), rhs: __v_114.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                        let __ret: [G; OUT_63] = [__v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113, __v_113];
+                                                                                                                                                                                                                                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                        return Ok(__ret);
+                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_112.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                        let __v_113: G = __loaded[0];
+                                                                                                                                                                                                                                        let __v_114: G = __loaded[1];
+                                                                                                                                                                                                                                        match __v_114.as_canonical_u64() {
                                                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                            let __v_175: G = __loaded[0];
-                                                                                                                                                                                                                                            let __v_176: G = __loaded[1];
-                                                                                                                                                                                                                                            let __v_177: G = __loaded[2];
-                                                                                                                                                                                                                                            match __v_175.as_canonical_u64() {
+                                                                                                                                                                                                                                            let __v_115: G = G::from_u64(0);
+                                                                                                                                                                                                                                            let __v_116: G = G::from_u64(1);
+                                                                                                                                                                                                                                            if (__v_115 != __v_116) {
+                                                                                                                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_115.as_canonical_u64(), rhs: __v_116.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                            let __ret: [G; OUT_63] = [__v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115, __v_115];
+                                                                                                                                                                                                                                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                            return Ok(__ret);
+                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                            let __v_115: G = __loaded[0];
+                                                                                                                                                                                                                                            let __v_116: G = __loaded[1];
+                                                                                                                                                                                                                                            match __v_116.as_canonical_u64() {
                                                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                let __v_178: G = __loaded[0];
-                                                                                                                                                                                                                                                let __v_179: G = __loaded[1];
-                                                                                                                                                                                                                                                let __v_180: G = __loaded[2];
-                                                                                                                                                                                                                                                match __v_178.as_canonical_u64() {
+                                                                                                                                                                                                                                                let __v_117: G = G::from_u64(0);
+                                                                                                                                                                                                                                                let __v_118: G = G::from_u64(1);
+                                                                                                                                                                                                                                                if (__v_117 != __v_118) {
+                                                                                                                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_117.as_canonical_u64(), rhs: __v_118.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                let __ret: [G; OUT_63] = [__v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117, __v_117];
+                                                                                                                                                                                                                                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                return Ok(__ret);
+                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_116.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                let __v_117: G = __loaded[0];
+                                                                                                                                                                                                                                                let __v_118: G = __loaded[1];
+                                                                                                                                                                                                                                                match __v_118.as_canonical_u64() {
                                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                    let __v_181: G = __loaded[0];
-                                                                                                                                                                                                                                                    let __v_182: G = __loaded[1];
-                                                                                                                                                                                                                                                    let __v_183: G = __loaded[2];
-                                                                                                                                                                                                                                                    match __v_181.as_canonical_u64() {
+                                                                                                                                                                                                                                                    let __v_119: G = G::from_u64(0);
+                                                                                                                                                                                                                                                    let __v_120: G = G::from_u64(1);
+                                                                                                                                                                                                                                                    if (__v_119 != __v_120) {
+                                                                                                                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_119.as_canonical_u64(), rhs: __v_120.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                    let __ret: [G; OUT_63] = [__v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119, __v_119];
+                                                                                                                                                                                                                                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_118.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                    let __v_119: G = __loaded[0];
+                                                                                                                                                                                                                                                    let __v_120: G = __loaded[1];
+                                                                                                                                                                                                                                                    match __v_120.as_canonical_u64() {
                                                                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                        let __v_184: G = __loaded[0];
-                                                                                                                                                                                                                                                        let __v_185: G = __loaded[1];
-                                                                                                                                                                                                                                                        let __v_186: G = __loaded[2];
-                                                                                                                                                                                                                                                        match __v_184.as_canonical_u64() {
+                                                                                                                                                                                                                                                        let __v_121: G = G::from_u64(0);
+                                                                                                                                                                                                                                                        let __v_122: G = G::from_u64(1);
+                                                                                                                                                                                                                                                        if (__v_121 != __v_122) {
+                                                                                                                                                                                                                                                          return Err(ExecError::AssertEqMismatch { lhs: __v_121.as_canonical_u64(), rhs: __v_122.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                        let __ret: [G; OUT_63] = [__v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121, __v_121];
+                                                                                                                                                                                                                                                        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                        return Ok(__ret);
+                                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                                                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                        let __v_121: G = __loaded[0];
+                                                                                                                                                                                                                                                        let __v_122: G = __loaded[1];
+                                                                                                                                                                                                                                                        match __v_122.as_canonical_u64() {
                                                                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                            let __v_187: G = __loaded[0];
-                                                                                                                                                                                                                                                            let __v_188: G = __loaded[1];
-                                                                                                                                                                                                                                                            let __v_189: G = __loaded[2];
-                                                                                                                                                                                                                                                            match __v_187.as_canonical_u64() {
+                                                                                                                                                                                                                                                            let __v_123: G = G::from_u64(0);
+                                                                                                                                                                                                                                                            let __v_124: G = G::from_u64(1);
+                                                                                                                                                                                                                                                            if (__v_123 != __v_124) {
+                                                                                                                                                                                                                                                              return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_124.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                            let __ret: [G; OUT_63] = [__v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123, __v_123];
+                                                                                                                                                                                                                                                            record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                            return Ok(__ret);
+                                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                                                            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_122.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                            let __v_123: G = __loaded[0];
+                                                                                                                                                                                                                                                            let __v_124: G = __loaded[1];
+                                                                                                                                                                                                                                                            match __v_124.as_canonical_u64() {
                                                                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                                                                                                                                                                                                                                                let __v_190: G = __loaded[0];
-                                                                                                                                                                                                                                                                let __v_191: G = __loaded[1];
-                                                                                                                                                                                                                                                                let __v_192: G = __loaded[2];
-                                                                                                                                                                                                                                                                match __v_190.as_canonical_u64() {
+                                                                                                                                                                                                                                                                let __v_125: G = G::from_u64(0);
+                                                                                                                                                                                                                                                                let __v_126: G = G::from_u64(1);
+                                                                                                                                                                                                                                                                if (__v_125 != __v_126) {
+                                                                                                                                                                                                                                                                  return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                let __ret: [G; OUT_63] = [__v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125, __v_125];
+                                                                                                                                                                                                                                                                record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                                return Ok(__ret);
+                                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                                                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_124.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                                let __v_125: G = __loaded[0];
+                                                                                                                                                                                                                                                                let __v_126: G = __loaded[1];
+                                                                                                                                                                                                                                                                match __v_126.as_canonical_u64() {
                                                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                                                    let __ret: [G; OUT_63] = [__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];
+                                                                                                                                                                                                                                                                    let __v_127: G = G::from_u64(0);
+                                                                                                                                                                                                                                                                    let __v_128: G = G::from_u64(1);
+                                                                                                                                                                                                                                                                    if (__v_127 != __v_128) {
+                                                                                                                                                                                                                                                                      return Err(ExecError::AssertEqMismatch { lhs: __v_127.as_canonical_u64(), rhs: __v_128.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                                    let __ret: [G; OUT_63] = [__v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127, __v_127];
                                                                                                                                                                                                                                                                     record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                                                                                                                                                                     return Ok(__ret);
                                                                                                                                                                                                                                                                   },
                                                                                                                                                                                                                                                                   _ => {
-                                                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_190.as_canonical_u64()));
+                                                                                                                                                                                                                                                                    let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                                    let __v_127: G = __loaded[0];
+                                                                                                                                                                                                                                                                    let __v_128: G = __loaded[1];
+                                                                                                                                                                                                                                                                    let __ret: [G; OUT_63] = [__v_127, __v_125, __v_123, __v_121, __v_119, __v_117, __v_115, __v_113, __v_111, __v_109, __v_107, __v_105, __v_103, __v_101, __v_99, __v_97, __v_95, __v_93, __v_91, __v_89, __v_87, __v_85, __v_83, __v_81, __v_79, __v_77, __v_75, __v_73, __v_71, __v_69, __v_67, __v_65, __v_63, __v_61, __v_59, __v_57, __v_55, __v_53, __v_51, __v_49, __v_47, __v_45, __v_43, __v_41, __v_39, __v_37, __v_35, __v_33, __v_31, __v_29, __v_27, __v_25, __v_23, __v_21, __v_19, __v_17, __v_15, __v_13, __v_11, __v_9, __v_7, __v_5, __v_3, __v_1];
+                                                                                                                                                                                                                                                                    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                                    return Ok(__ret);
                                                                                                                                                                                                                                                                   },
                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                               },
-                                                                                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_187.as_canonical_u64()));
-                                                                                                                                                                                                                                                              },
                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                           },
-                                                                                                                                                                                                                                                          _ => {
-                                                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_184.as_canonical_u64()));
-                                                                                                                                                                                                                                                          },
                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                       },
-                                                                                                                                                                                                                                                      _ => {
-                                                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_181.as_canonical_u64()));
-                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                     }
                                                                                                                                                                                                                                                   },
-                                                                                                                                                                                                                                                  _ => {
-                                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_178.as_canonical_u64()));
-                                                                                                                                                                                                                                                  },
                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                               },
-                                                                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_175.as_canonical_u64()));
-                                                                                                                                                                                                                                              },
                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                           },
-                                                                                                                                                                                                                                          _ => {
-                                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_172.as_canonical_u64()));
-                                                                                                                                                                                                                                          },
                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                       },
-                                                                                                                                                                                                                                      _ => {
-                                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_169.as_canonical_u64()));
-                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                     }
                                                                                                                                                                                                                                   },
-                                                                                                                                                                                                                                  _ => {
-                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_166.as_canonical_u64()));
-                                                                                                                                                                                                                                  },
                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                               },
-                                                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_163.as_canonical_u64()));
-                                                                                                                                                                                                                              },
                                                                                                                                                                                                                             }
                                                                                                                                                                                                                           },
-                                                                                                                                                                                                                          _ => {
-                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64()));
-                                                                                                                                                                                                                          },
                                                                                                                                                                                                                         }
                                                                                                                                                                                                                       },
-                                                                                                                                                                                                                      _ => {
-                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_157.as_canonical_u64()));
-                                                                                                                                                                                                                      },
                                                                                                                                                                                                                     }
                                                                                                                                                                                                                   },
-                                                                                                                                                                                                                  _ => {
-                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_154.as_canonical_u64()));
-                                                                                                                                                                                                                  },
                                                                                                                                                                                                                 }
                                                                                                                                                                                                               },
-                                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_151.as_canonical_u64()));
-                                                                                                                                                                                                              },
                                                                                                                                                                                                             }
                                                                                                                                                                                                           },
-                                                                                                                                                                                                          _ => {
-                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_148.as_canonical_u64()));
-                                                                                                                                                                                                          },
                                                                                                                                                                                                         }
                                                                                                                                                                                                       },
-                                                                                                                                                                                                      _ => {
-                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_145.as_canonical_u64()));
-                                                                                                                                                                                                      },
                                                                                                                                                                                                     }
                                                                                                                                                                                                   },
-                                                                                                                                                                                                  _ => {
-                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_142.as_canonical_u64()));
-                                                                                                                                                                                                  },
                                                                                                                                                                                                 }
                                                                                                                                                                                               },
-                                                                                                                                                                                              _ => {
-                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_139.as_canonical_u64()));
-                                                                                                                                                                                              },
                                                                                                                                                                                             }
                                                                                                                                                                                           },
-                                                                                                                                                                                          _ => {
-                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_136.as_canonical_u64()));
-                                                                                                                                                                                          },
                                                                                                                                                                                         }
                                                                                                                                                                                       },
-                                                                                                                                                                                      _ => {
-                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64()));
-                                                                                                                                                                                      },
                                                                                                                                                                                     }
                                                                                                                                                                                   },
-                                                                                                                                                                                  _ => {
-                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_130.as_canonical_u64()));
-                                                                                                                                                                                  },
                                                                                                                                                                                 }
                                                                                                                                                                               },
-                                                                                                                                                                              _ => {
-                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_127.as_canonical_u64()));
-                                                                                                                                                                              },
                                                                                                                                                                             }
                                                                                                                                                                           },
-                                                                                                                                                                          _ => {
-                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64()));
-                                                                                                                                                                          },
                                                                                                                                                                         }
                                                                                                                                                                       },
-                                                                                                                                                                      _ => {
-                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64()));
-                                                                                                                                                                      },
                                                                                                                                                                     }
                                                                                                                                                                   },
-                                                                                                                                                                  _ => {
-                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64()));
-                                                                                                                                                                  },
                                                                                                                                                                 }
                                                                                                                                                               },
-                                                                                                                                                              _ => {
-                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64()));
-                                                                                                                                                              },
                                                                                                                                                             }
                                                                                                                                                           },
-                                                                                                                                                          _ => {
-                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64()));
-                                                                                                                                                          },
                                                                                                                                                         }
                                                                                                                                                       },
-                                                                                                                                                      _ => {
-                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64()));
-                                                                                                                                                      },
                                                                                                                                                     }
                                                                                                                                                   },
-                                                                                                                                                  _ => {
-                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64()));
-                                                                                                                                                  },
                                                                                                                                                 }
                                                                                                                                               },
-                                                                                                                                              _ => {
-                                                                                                                                                return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64()));
-                                                                                                                                              },
                                                                                                                                             }
                                                                                                                                           },
-                                                                                                                                          _ => {
-                                                                                                                                            return Err(ExecError::MatchNoCase(__v_100.as_canonical_u64()));
-                                                                                                                                          },
                                                                                                                                         }
                                                                                                                                       },
-                                                                                                                                      _ => {
-                                                                                                                                        return Err(ExecError::MatchNoCase(__v_97.as_canonical_u64()));
-                                                                                                                                      },
                                                                                                                                     }
                                                                                                                                   },
-                                                                                                                                  _ => {
-                                                                                                                                    return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64()));
-                                                                                                                                  },
                                                                                                                                 }
                                                                                                                               },
-                                                                                                                              _ => {
-                                                                                                                                return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64()));
-                                                                                                                              },
                                                                                                                             }
                                                                                                                           },
-                                                                                                                          _ => {
-                                                                                                                            return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64()));
-                                                                                                                          },
                                                                                                                         }
                                                                                                                       },
-                                                                                                                      _ => {
-                                                                                                                        return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64()));
-                                                                                                                      },
                                                                                                                     }
                                                                                                                   },
-                                                                                                                  _ => {
-                                                                                                                    return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64()));
-                                                                                                                  },
                                                                                                                 }
                                                                                                               },
-                                                                                                              _ => {
-                                                                                                                return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64()));
-                                                                                                              },
                                                                                                             }
                                                                                                           },
-                                                                                                          _ => {
-                                                                                                            return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64()));
-                                                                                                          },
                                                                                                         }
                                                                                                       },
-                                                                                                      _ => {
-                                                                                                        return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64()));
-                                                                                                      },
                                                                                                     }
                                                                                                   },
-                                                                                                  _ => {
-                                                                                                    return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64()));
-                                                                                                  },
                                                                                                 }
                                                                                               },
-                                                                                              _ => {
-                                                                                                return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64()));
-                                                                                              },
                                                                                             }
                                                                                           },
-                                                                                          _ => {
-                                                                                            return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64()));
-                                                                                          },
                                                                                         }
                                                                                       },
-                                                                                      _ => {
-                                                                                        return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
-                                                                                      },
                                                                                     }
                                                                                   },
-                                                                                  _ => {
-                                                                                    return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64()));
-                                                                                  },
                                                                                 }
                                                                               },
-                                                                              _ => {
-                                                                                return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64()));
-                                                                              },
                                                                             }
                                                                           },
-                                                                          _ => {
-                                                                            return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64()));
-                                                                          },
                                                                         }
                                                                       },
-                                                                      _ => {
-                                                                        return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64()));
-                                                                      },
                                                                     }
                                                                   },
-                                                                  _ => {
-                                                                    return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64()));
-                                                                  },
                                                                 }
                                                               },
-                                                              _ => {
-                                                                return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64()));
-                                                              },
                                                             }
                                                           },
-                                                          _ => {
-                                                            return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64()));
-                                                          },
                                                         }
                                                       },
-                                                      _ => {
-                                                        return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64()));
-                                                      },
                                                     }
                                                   },
-                                                  _ => {
-                                                    return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
-                                                  },
                                                 }
                                               },
-                                              _ => {
-                                                return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
-                                              },
                                             }
                                           },
-                                          _ => {
-                                            return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
-                                          },
                                         }
                                       },
-                                      _ => {
-                                        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
-                                      },
                                     }
                                   },
-                                  _ => {
-                                    return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
-                                  },
                                 }
                               },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
-                              },
                             }
                           },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-                          },
                         }
                       },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-                      },
                     }
                   },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-                  },
                 }
               },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-              },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -3814,13 +3943,12 @@ fn aiur_fn_64(
       },
       _ => {
         let __v_2: G = G::from_u64(0);
-        let __v_3: G = G::from_u64(0);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = (__v_1 - __v_5);
-        let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_4, __v_6]; 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_64] = [__v_7];
+        let __v_3: G = { let __values: [G; 2] = [__v_2, __v_0]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_64] = [__v_6];
         record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -3851,7 +3979,7 @@ fn aiur_fn_65(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+            let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
             let __v_9: G = __loaded[0];
             let __v_10: G = __loaded[1];
             let __v_11: G = __loaded[2];
@@ -3878,40 +4006,40 @@ fn aiur_fn_65(
                                           0u64 => {
                                             let __v_17: G = (__v_6 + __v_7);
                                             let __v_18: G = (__v_8 + __v_17);
-                                            let __v_19: G = G::from_u64(0);
-                                            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-                                            let __v_20: G = __loaded[0];
-                                            let __v_21: G = __loaded[1];
-                                            let __v_22: G = __loaded[2];
-                                            let __v_23: G = __loaded[3];
-                                            let __v_24: G = __loaded[4];
-                                            let __v_25: G = __loaded[5];
-                                            let __v_26: G = __loaded[6];
-                                            let __v_27: G = __loaded[7];
-                                            let __v_28: G = __loaded[8];
-                                            let __v_29: G = __loaded[9];
-                                            let __v_30: G = __loaded[10];
-                                            let __v_31: G = __loaded[11];
-                                            let __v_32: G = __loaded[12];
-                                            let __v_33: G = __loaded[13];
-                                            let __v_34: G = __loaded[14];
-                                            let __v_35: G = __loaded[15];
-                                            let __v_36: G = __loaded[16];
-                                            let __v_37: G = __loaded[17];
-                                            let __v_38: G = __loaded[18];
-                                            let __v_39: G = __loaded[19];
-                                            let __v_40: G = __loaded[20];
-                                            let __v_41: G = __loaded[21];
-                                            let __v_42: G = __loaded[22];
-                                            let __v_43: G = __loaded[23];
-                                            let __v_44: G = __loaded[24];
-                                            let __v_45: G = __loaded[25];
-                                            let __v_46: G = __loaded[26];
-                                            let __v_47: G = __loaded[27];
-                                            let __v_48: G = __loaded[28];
-                                            let __v_49: G = __loaded[29];
-                                            let __v_50: G = __loaded[30];
-                                            let __v_51: G = __loaded[31];
+                                            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+                                            let __v_19: G = __loaded[0];
+                                            let __v_20: G = __loaded[1];
+                                            let __v_21: G = __loaded[2];
+                                            let __v_22: G = __loaded[3];
+                                            let __v_23: G = __loaded[4];
+                                            let __v_24: G = __loaded[5];
+                                            let __v_25: G = __loaded[6];
+                                            let __v_26: G = __loaded[7];
+                                            let __v_27: G = __loaded[8];
+                                            let __v_28: G = __loaded[9];
+                                            let __v_29: G = __loaded[10];
+                                            let __v_30: G = __loaded[11];
+                                            let __v_31: G = __loaded[12];
+                                            let __v_32: G = __loaded[13];
+                                            let __v_33: G = __loaded[14];
+                                            let __v_34: G = __loaded[15];
+                                            let __v_35: G = __loaded[16];
+                                            let __v_36: G = __loaded[17];
+                                            let __v_37: G = __loaded[18];
+                                            let __v_38: G = __loaded[19];
+                                            let __v_39: G = __loaded[20];
+                                            let __v_40: G = __loaded[21];
+                                            let __v_41: G = __loaded[22];
+                                            let __v_42: G = __loaded[23];
+                                            let __v_43: G = __loaded[24];
+                                            let __v_44: G = __loaded[25];
+                                            let __v_45: G = __loaded[26];
+                                            let __v_46: G = __loaded[27];
+                                            let __v_47: G = __loaded[28];
+                                            let __v_48: G = __loaded[29];
+                                            let __v_49: G = __loaded[30];
+                                            let __v_50: G = __loaded[31];
+                                            let __v_51: G = G::from_u64(0);
                                             let __v_52: G = G::from_u64(0);
                                             let __v_53: G = G::from_u64(0);
                                             let __v_54: G = G::from_u64(0);
@@ -3975,52 +4103,51 @@ fn aiur_fn_65(
                                             let __v_112: G = G::from_u64(0);
                                             let __v_113: G = G::from_u64(0);
                                             let __v_114: G = G::from_u64(0);
-                                            let __v_115: G = G::from_u64(0);
-                                            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-                                            let __v_116: G = __loaded[0];
-                                            let __v_117: G = __loaded[1];
-                                            let __v_118: G = __loaded[2];
-                                            let __v_119: G = __loaded[3];
-                                            let __v_120: G = __loaded[4];
-                                            let __v_121: G = __loaded[5];
-                                            let __v_122: G = __loaded[6];
-                                            let __v_123: G = __loaded[7];
-                                            let __v_124: G = G::from_u64(0);
-                                            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[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_125: G = __r_arr[0];
-                                            let __v_126: G = __r_arr[1];
-                                            let __v_127: G = __r_arr[2];
-                                            let __v_128: G = __r_arr[3];
-                                            let __v_129: G = __r_arr[4];
-                                            let __v_130: G = __r_arr[5];
-                                            let __v_131: G = __r_arr[6];
-                                            let __v_132: G = __r_arr[7];
-                                            let __v_133: G = __r_arr[8];
-                                            let __v_134: G = __r_arr[9];
-                                            let __v_135: G = __r_arr[10];
-                                            let __v_136: G = __r_arr[11];
-                                            let __v_137: G = __r_arr[12];
-                                            let __v_138: G = __r_arr[13];
-                                            let __v_139: G = __r_arr[14];
-                                            let __v_140: G = __r_arr[15];
-                                            let __v_141: G = __r_arr[16];
-                                            let __v_142: G = __r_arr[17];
-                                            let __v_143: G = __r_arr[18];
-                                            let __v_144: G = __r_arr[19];
-                                            let __v_145: G = __r_arr[20];
-                                            let __v_146: G = __r_arr[21];
-                                            let __v_147: G = __r_arr[22];
-                                            let __v_148: G = __r_arr[23];
-                                            let __v_149: G = __r_arr[24];
-                                            let __v_150: G = __r_arr[25];
-                                            let __v_151: G = __r_arr[26];
-                                            let __v_152: G = __r_arr[27];
-                                            let __v_153: G = __r_arr[28];
-                                            let __v_154: G = __r_arr[29];
-                                            let __v_155: G = __r_arr[30];
-                                            let __v_156: G = __r_arr[31];
-                                            let __v_157: G = { let __values: [G; 34] = [__v_19, __v_5, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_65] = [__v_157];
+                                            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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                                            let __v_115: G = __loaded[0];
+                                            let __v_116: G = __loaded[1];
+                                            let __v_117: G = __loaded[2];
+                                            let __v_118: G = __loaded[3];
+                                            let __v_119: G = __loaded[4];
+                                            let __v_120: G = __loaded[5];
+                                            let __v_121: G = __loaded[6];
+                                            let __v_122: G = __loaded[7];
+                                            let __v_123: G = G::from_u64(0);
+                                            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_18]; 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_124: G = __r_arr[0];
+                                            let __v_125: G = __r_arr[1];
+                                            let __v_126: G = __r_arr[2];
+                                            let __v_127: G = __r_arr[3];
+                                            let __v_128: G = __r_arr[4];
+                                            let __v_129: G = __r_arr[5];
+                                            let __v_130: G = __r_arr[6];
+                                            let __v_131: G = __r_arr[7];
+                                            let __v_132: G = __r_arr[8];
+                                            let __v_133: G = __r_arr[9];
+                                            let __v_134: G = __r_arr[10];
+                                            let __v_135: G = __r_arr[11];
+                                            let __v_136: G = __r_arr[12];
+                                            let __v_137: G = __r_arr[13];
+                                            let __v_138: G = __r_arr[14];
+                                            let __v_139: G = __r_arr[15];
+                                            let __v_140: G = __r_arr[16];
+                                            let __v_141: G = __r_arr[17];
+                                            let __v_142: G = __r_arr[18];
+                                            let __v_143: G = __r_arr[19];
+                                            let __v_144: G = __r_arr[20];
+                                            let __v_145: G = __r_arr[21];
+                                            let __v_146: G = __r_arr[22];
+                                            let __v_147: G = __r_arr[23];
+                                            let __v_148: G = __r_arr[24];
+                                            let __v_149: G = __r_arr[25];
+                                            let __v_150: G = __r_arr[26];
+                                            let __v_151: G = __r_arr[27];
+                                            let __v_152: G = __r_arr[28];
+                                            let __v_153: G = __r_arr[29];
+                                            let __v_154: G = __r_arr[30];
+                                            let __v_155: G = __r_arr[31];
+                                            let __v_156: G = { let __values: [G; 33] = [__v_5, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __ret: [G; OUT_65] = [__v_156];
                                             record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
@@ -4081,49 +4208,48 @@ fn aiur_fn_65(
             }
           },
           _ => {
-            let __v_9: G = G::from_u64(0);
-            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-            let __v_10: G = __loaded[0];
-            let __v_11: G = __loaded[1];
-            let __v_12: G = __loaded[2];
-            let __v_13: G = __loaded[3];
-            let __v_14: G = __loaded[4];
-            let __v_15: G = __loaded[5];
-            let __v_16: G = __loaded[6];
-            let __v_17: G = __loaded[7];
-            let __v_18: G = __loaded[8];
-            let __v_19: G = __loaded[9];
-            let __v_20: G = __loaded[10];
-            let __v_21: G = __loaded[11];
-            let __v_22: G = __loaded[12];
-            let __v_23: G = __loaded[13];
-            let __v_24: G = __loaded[14];
-            let __v_25: G = __loaded[15];
-            let __v_26: G = __loaded[16];
-            let __v_27: G = __loaded[17];
-            let __v_28: G = __loaded[18];
-            let __v_29: G = __loaded[19];
-            let __v_30: G = __loaded[20];
-            let __v_31: G = __loaded[21];
-            let __v_32: G = __loaded[22];
-            let __v_33: G = __loaded[23];
-            let __v_34: G = __loaded[24];
-            let __v_35: G = __loaded[25];
-            let __v_36: G = __loaded[26];
-            let __v_37: G = __loaded[27];
-            let __v_38: G = __loaded[28];
-            let __v_39: G = __loaded[29];
-            let __v_40: G = __loaded[30];
-            let __v_41: G = __loaded[31];
-            let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_65] = [__v_42];
+            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_9: G = __loaded[0];
+            let __v_10: G = __loaded[1];
+            let __v_11: G = __loaded[2];
+            let __v_12: G = __loaded[3];
+            let __v_13: G = __loaded[4];
+            let __v_14: G = __loaded[5];
+            let __v_15: G = __loaded[6];
+            let __v_16: G = __loaded[7];
+            let __v_17: G = __loaded[8];
+            let __v_18: G = __loaded[9];
+            let __v_19: G = __loaded[10];
+            let __v_20: G = __loaded[11];
+            let __v_21: G = __loaded[12];
+            let __v_22: G = __loaded[13];
+            let __v_23: G = __loaded[14];
+            let __v_24: G = __loaded[15];
+            let __v_25: G = __loaded[16];
+            let __v_26: G = __loaded[17];
+            let __v_27: G = __loaded[18];
+            let __v_28: G = __loaded[19];
+            let __v_29: G = __loaded[20];
+            let __v_30: G = __loaded[21];
+            let __v_31: G = __loaded[22];
+            let __v_32: G = __loaded[23];
+            let __v_33: G = __loaded[24];
+            let __v_34: G = __loaded[25];
+            let __v_35: G = __loaded[26];
+            let __v_36: G = __loaded[27];
+            let __v_37: G = __loaded[28];
+            let __v_38: G = __loaded[29];
+            let __v_39: G = __loaded[30];
+            let __v_40: G = __loaded[31];
+            let __v_41: G = { let __values: [G; 33] = [__v_5, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_65] = [__v_41];
             record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -4209,84 +4335,83 @@ fn aiur_fn_65(
         let __v_88: G = __r_arr[61];
         let __v_89: G = __r_arr[62];
         let __v_90: G = __r_arr[63];
-        let __v_91: G = G::from_u64(0);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_92: G = __loaded[0];
-        let __v_93: G = __loaded[1];
-        let __v_94: G = __loaded[2];
-        let __v_95: G = __loaded[3];
-        let __v_96: G = __loaded[4];
-        let __v_97: G = __loaded[5];
-        let __v_98: G = __loaded[6];
-        let __v_99: G = __loaded[7];
-        let __v_100: G = __loaded[8];
-        let __v_101: G = __loaded[9];
-        let __v_102: G = __loaded[10];
-        let __v_103: G = __loaded[11];
-        let __v_104: G = __loaded[12];
-        let __v_105: G = __loaded[13];
-        let __v_106: G = __loaded[14];
-        let __v_107: G = __loaded[15];
-        let __v_108: G = __loaded[16];
-        let __v_109: G = __loaded[17];
-        let __v_110: G = __loaded[18];
-        let __v_111: G = __loaded[19];
-        let __v_112: G = __loaded[20];
-        let __v_113: G = __loaded[21];
-        let __v_114: G = __loaded[22];
-        let __v_115: G = __loaded[23];
-        let __v_116: G = __loaded[24];
-        let __v_117: G = __loaded[25];
-        let __v_118: G = __loaded[26];
-        let __v_119: G = __loaded[27];
-        let __v_120: G = __loaded[28];
-        let __v_121: G = __loaded[29];
-        let __v_122: G = __loaded[30];
-        let __v_123: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_124: G = __loaded[0];
-        let __v_125: G = __loaded[1];
-        let __v_126: G = __loaded[2];
-        let __v_127: G = __loaded[3];
-        let __v_128: G = __loaded[4];
-        let __v_129: G = __loaded[5];
-        let __v_130: G = __loaded[6];
-        let __v_131: G = __loaded[7];
-        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__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[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_132: G = __r_arr[0];
-        let __v_133: G = __r_arr[1];
-        let __v_134: G = __r_arr[2];
-        let __v_135: G = __r_arr[3];
-        let __v_136: G = __r_arr[4];
-        let __v_137: G = __r_arr[5];
-        let __v_138: G = __r_arr[6];
-        let __v_139: G = __r_arr[7];
-        let __v_140: G = __r_arr[8];
-        let __v_141: G = __r_arr[9];
-        let __v_142: G = __r_arr[10];
-        let __v_143: G = __r_arr[11];
-        let __v_144: G = __r_arr[12];
-        let __v_145: G = __r_arr[13];
-        let __v_146: G = __r_arr[14];
-        let __v_147: G = __r_arr[15];
-        let __v_148: G = __r_arr[16];
-        let __v_149: G = __r_arr[17];
-        let __v_150: G = __r_arr[18];
-        let __v_151: G = __r_arr[19];
-        let __v_152: G = __r_arr[20];
-        let __v_153: G = __r_arr[21];
-        let __v_154: G = __r_arr[22];
-        let __v_155: G = __r_arr[23];
-        let __v_156: G = __r_arr[24];
-        let __v_157: G = __r_arr[25];
-        let __v_158: G = __r_arr[26];
-        let __v_159: G = __r_arr[27];
-        let __v_160: G = __r_arr[28];
-        let __v_161: G = __r_arr[29];
-        let __v_162: G = __r_arr[30];
-        let __v_163: G = __r_arr[31];
-        let __v_164: G = { let __values: [G; 34] = [__v_91, __v_5, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_65] = [__v_164];
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_91: G = __loaded[0];
+        let __v_92: G = __loaded[1];
+        let __v_93: G = __loaded[2];
+        let __v_94: G = __loaded[3];
+        let __v_95: G = __loaded[4];
+        let __v_96: G = __loaded[5];
+        let __v_97: G = __loaded[6];
+        let __v_98: G = __loaded[7];
+        let __v_99: G = __loaded[8];
+        let __v_100: G = __loaded[9];
+        let __v_101: G = __loaded[10];
+        let __v_102: G = __loaded[11];
+        let __v_103: G = __loaded[12];
+        let __v_104: G = __loaded[13];
+        let __v_105: G = __loaded[14];
+        let __v_106: G = __loaded[15];
+        let __v_107: G = __loaded[16];
+        let __v_108: G = __loaded[17];
+        let __v_109: G = __loaded[18];
+        let __v_110: G = __loaded[19];
+        let __v_111: G = __loaded[20];
+        let __v_112: G = __loaded[21];
+        let __v_113: G = __loaded[22];
+        let __v_114: G = __loaded[23];
+        let __v_115: G = __loaded[24];
+        let __v_116: G = __loaded[25];
+        let __v_117: G = __loaded[26];
+        let __v_118: G = __loaded[27];
+        let __v_119: G = __loaded[28];
+        let __v_120: G = __loaded[29];
+        let __v_121: G = __loaded[30];
+        let __v_122: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_123: G = __loaded[0];
+        let __v_124: G = __loaded[1];
+        let __v_125: G = __loaded[2];
+        let __v_126: G = __loaded[3];
+        let __v_127: G = __loaded[4];
+        let __v_128: G = __loaded[5];
+        let __v_129: G = __loaded[6];
+        let __v_130: G = __loaded[7];
+        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__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_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_23]; 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_131: G = __r_arr[0];
+        let __v_132: G = __r_arr[1];
+        let __v_133: G = __r_arr[2];
+        let __v_134: G = __r_arr[3];
+        let __v_135: G = __r_arr[4];
+        let __v_136: G = __r_arr[5];
+        let __v_137: G = __r_arr[6];
+        let __v_138: G = __r_arr[7];
+        let __v_139: G = __r_arr[8];
+        let __v_140: G = __r_arr[9];
+        let __v_141: G = __r_arr[10];
+        let __v_142: G = __r_arr[11];
+        let __v_143: G = __r_arr[12];
+        let __v_144: G = __r_arr[13];
+        let __v_145: G = __r_arr[14];
+        let __v_146: G = __r_arr[15];
+        let __v_147: G = __r_arr[16];
+        let __v_148: G = __r_arr[17];
+        let __v_149: G = __r_arr[18];
+        let __v_150: G = __r_arr[19];
+        let __v_151: G = __r_arr[20];
+        let __v_152: G = __r_arr[21];
+        let __v_153: G = __r_arr[22];
+        let __v_154: G = __r_arr[23];
+        let __v_155: G = __r_arr[24];
+        let __v_156: G = __r_arr[25];
+        let __v_157: G = __r_arr[26];
+        let __v_158: G = __r_arr[27];
+        let __v_159: G = __r_arr[28];
+        let __v_160: G = __r_arr[29];
+        let __v_161: G = __r_arr[30];
+        let __v_162: G = __r_arr[31];
+        let __v_163: G = { let __values: [G; 33] = [__v_5, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_65] = [__v_163];
         record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -4382,7 +4507,7 @@ fn aiur_fn_66(
       1023u64 => {
         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 __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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_74: G = __loaded[0];
         let __v_75: G = __loaded[1];
         let __v_76: G = __loaded[2];
@@ -4428,112 +4553,109 @@ fn aiur_fn_66(
         let __v_115: G = G::from_u64(205);
         let __v_116: G = G::from_u64(224);
         let __v_117: G = G::from_u64(91);
-        let __v_118: G = G::from_u64(0);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_119: G = __loaded[0];
-        let __v_120: G = __loaded[1];
-        let __v_121: G = __loaded[2];
-        let __v_122: G = __loaded[3];
-        let __v_123: G = __loaded[4];
-        let __v_124: G = __loaded[5];
-        let __v_125: G = __loaded[6];
-        let __v_126: G = __loaded[7];
-        let __v_127: G = __loaded[8];
-        let __v_128: G = __loaded[9];
-        let __v_129: G = __loaded[10];
-        let __v_130: G = __loaded[11];
-        let __v_131: G = __loaded[12];
-        let __v_132: G = __loaded[13];
-        let __v_133: G = __loaded[14];
-        let __v_134: G = __loaded[15];
-        let __v_135: G = __loaded[16];
-        let __v_136: G = __loaded[17];
-        let __v_137: G = __loaded[18];
-        let __v_138: G = __loaded[19];
-        let __v_139: G = __loaded[20];
-        let __v_140: G = __loaded[21];
-        let __v_141: G = __loaded[22];
-        let __v_142: G = __loaded[23];
-        let __v_143: G = __loaded[24];
-        let __v_144: G = __loaded[25];
-        let __v_145: G = __loaded[26];
-        let __v_146: G = __loaded[27];
-        let __v_147: G = __loaded[28];
-        let __v_148: G = __loaded[29];
-        let __v_149: G = __loaded[30];
-        let __v_150: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_151: G = __loaded[0];
-        let __v_152: G = __loaded[1];
-        let __v_153: G = __loaded[2];
-        let __v_154: G = __loaded[3];
-        let __v_155: G = __loaded[4];
-        let __v_156: G = __loaded[5];
-        let __v_157: G = __loaded[6];
-        let __v_158: G = __loaded[7];
-        let __v_159: G = G::from_u64(64);
-        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__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[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_160: G = __r_arr[0];
-        let __v_161: G = __r_arr[1];
-        let __v_162: G = __r_arr[2];
-        let __v_163: G = __r_arr[3];
-        let __v_164: G = __r_arr[4];
-        let __v_165: G = __r_arr[5];
-        let __v_166: G = __r_arr[6];
-        let __v_167: G = __r_arr[7];
-        let __v_168: G = __r_arr[8];
-        let __v_169: G = __r_arr[9];
-        let __v_170: G = __r_arr[10];
-        let __v_171: G = __r_arr[11];
-        let __v_172: G = __r_arr[12];
-        let __v_173: G = __r_arr[13];
-        let __v_174: G = __r_arr[14];
-        let __v_175: G = __r_arr[15];
-        let __v_176: G = __r_arr[16];
-        let __v_177: G = __r_arr[17];
-        let __v_178: G = __r_arr[18];
-        let __v_179: G = __r_arr[19];
-        let __v_180: G = __r_arr[20];
-        let __v_181: G = __r_arr[21];
-        let __v_182: G = __r_arr[22];
-        let __v_183: G = __r_arr[23];
-        let __v_184: G = __r_arr[24];
-        let __v_185: G = __r_arr[25];
-        let __v_186: G = __r_arr[26];
-        let __v_187: G = __r_arr[27];
-        let __v_188: G = __r_arr[28];
-        let __v_189: G = __r_arr[29];
-        let __v_190: G = __r_arr[30];
-        let __v_191: G = __r_arr[31];
-        let __v_192: G = { let __values: [G; 34] = [__v_118, __v_5, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_193: G = G::from_u64(1);
-        let __v_194: G = G::from_u64(1);
-        let __v_195: G = { let __values: [G; 3] = [__v_193, __v_194, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_196: G = G::from_u64(0);
-        let __v_197: G = G::from_u64(0);
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_198: G = __loaded[0];
-        let __v_199: G = __loaded[1];
-        let __v_200: G = __loaded[2];
-        let __v_201: G = __loaded[3];
-        let __v_202: G = __loaded[4];
-        let __v_203: G = __loaded[5];
-        let __v_204: G = __loaded[6];
-        let __v_205: G = __loaded[7];
-        let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205]; let __cu = unconstrained; if let Some(result) = record.function_queries[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__args, record, io_buffer, __cu)? } };
-        let __v_206: G = __r_arr[0];
-        let __v_207: G = __r_arr[1];
-        let __v_208: G = __r_arr[2];
-        let __v_209: G = __r_arr[3];
-        let __v_210: G = __r_arr[4];
-        let __v_211: G = __r_arr[5];
-        let __v_212: G = __r_arr[6];
-        let __v_213: G = __r_arr[7];
-        let __v_214: G = { let __values: [G; 8] = [__v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_215: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; 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_216: G = __r_arr[0];
-        let __ret: [G; OUT_66] = [__v_216];
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_118: G = __loaded[0];
+        let __v_119: G = __loaded[1];
+        let __v_120: G = __loaded[2];
+        let __v_121: G = __loaded[3];
+        let __v_122: G = __loaded[4];
+        let __v_123: G = __loaded[5];
+        let __v_124: G = __loaded[6];
+        let __v_125: G = __loaded[7];
+        let __v_126: G = __loaded[8];
+        let __v_127: G = __loaded[9];
+        let __v_128: G = __loaded[10];
+        let __v_129: G = __loaded[11];
+        let __v_130: G = __loaded[12];
+        let __v_131: G = __loaded[13];
+        let __v_132: G = __loaded[14];
+        let __v_133: G = __loaded[15];
+        let __v_134: G = __loaded[16];
+        let __v_135: G = __loaded[17];
+        let __v_136: G = __loaded[18];
+        let __v_137: G = __loaded[19];
+        let __v_138: G = __loaded[20];
+        let __v_139: G = __loaded[21];
+        let __v_140: G = __loaded[22];
+        let __v_141: G = __loaded[23];
+        let __v_142: G = __loaded[24];
+        let __v_143: G = __loaded[25];
+        let __v_144: G = __loaded[26];
+        let __v_145: G = __loaded[27];
+        let __v_146: G = __loaded[28];
+        let __v_147: G = __loaded[29];
+        let __v_148: G = __loaded[30];
+        let __v_149: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_150: G = __loaded[0];
+        let __v_151: G = __loaded[1];
+        let __v_152: G = __loaded[2];
+        let __v_153: G = __loaded[3];
+        let __v_154: G = __loaded[4];
+        let __v_155: G = __loaded[5];
+        let __v_156: G = __loaded[6];
+        let __v_157: G = __loaded[7];
+        let __v_158: G = G::from_u64(64);
+        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_85]; 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_159: G = __r_arr[0];
+        let __v_160: G = __r_arr[1];
+        let __v_161: G = __r_arr[2];
+        let __v_162: G = __r_arr[3];
+        let __v_163: G = __r_arr[4];
+        let __v_164: G = __r_arr[5];
+        let __v_165: G = __r_arr[6];
+        let __v_166: G = __r_arr[7];
+        let __v_167: G = __r_arr[8];
+        let __v_168: G = __r_arr[9];
+        let __v_169: G = __r_arr[10];
+        let __v_170: G = __r_arr[11];
+        let __v_171: G = __r_arr[12];
+        let __v_172: G = __r_arr[13];
+        let __v_173: G = __r_arr[14];
+        let __v_174: G = __r_arr[15];
+        let __v_175: G = __r_arr[16];
+        let __v_176: G = __r_arr[17];
+        let __v_177: G = __r_arr[18];
+        let __v_178: G = __r_arr[19];
+        let __v_179: G = __r_arr[20];
+        let __v_180: G = __r_arr[21];
+        let __v_181: G = __r_arr[22];
+        let __v_182: G = __r_arr[23];
+        let __v_183: G = __r_arr[24];
+        let __v_184: G = __r_arr[25];
+        let __v_185: G = __r_arr[26];
+        let __v_186: G = __r_arr[27];
+        let __v_187: G = __r_arr[28];
+        let __v_188: G = __r_arr[29];
+        let __v_189: G = __r_arr[30];
+        let __v_190: G = __r_arr[31];
+        let __v_191: G = { let __values: [G; 33] = [__v_5, __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]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_192: G = G::from_u64(0);
+        let __v_193: G = G::from_u64(0);
+        let __v_194: G = G::from_u64(0);
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_195: G = __loaded[0];
+        let __v_196: G = __loaded[1];
+        let __v_197: G = __loaded[2];
+        let __v_198: G = __loaded[3];
+        let __v_199: G = __loaded[4];
+        let __v_200: G = __loaded[5];
+        let __v_201: G = __loaded[6];
+        let __v_202: G = __loaded[7];
+        let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202]; let __cu = unconstrained; if let Some(result) = record.function_queries[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__args, record, io_buffer, __cu)? } };
+        let __v_203: G = __r_arr[0];
+        let __v_204: G = __r_arr[1];
+        let __v_205: G = __r_arr[2];
+        let __v_206: G = __r_arr[3];
+        let __v_207: G = __r_arr[4];
+        let __v_208: G = __r_arr[5];
+        let __v_209: G = __r_arr[6];
+        let __v_210: G = __r_arr[7];
+        let __v_211: G = { let __values: [G; 8] = [__v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_212: 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_0, __v_192, __v_193, __v_194, __v_211, __v_212, __v_191]; 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_213: G = __r_arr[0];
+        let __ret: [G; OUT_66] = [__v_213];
         record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -4543,7 +4665,7 @@ fn aiur_fn_66(
         let __v_74: G = (__v_73 * __v_7);
         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 __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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_76: G = __loaded[0];
         let __v_77: G = __loaded[1];
         let __v_78: G = __loaded[2];
@@ -4562,7 +4684,7 @@ fn aiur_fn_66(
         let __v_90: G = (__v_89 * __v_6);
         let __v_91: G = (__v_86 + __v_90);
         let __v_92: G = (__v_74 + __v_91);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
         let __v_93: G = __loaded[0];
         let __v_94: G = __loaded[1];
         let __v_95: G = __loaded[2];
@@ -4595,7 +4717,7 @@ fn aiur_fn_66(
         let __v_122: G = __loaded[29];
         let __v_123: G = __loaded[30];
         let __v_124: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_125: G = __loaded[0];
         let __v_126: G = __loaded[1];
         let __v_127: G = __loaded[2];
@@ -4638,16 +4760,14 @@ fn aiur_fn_66(
         let __v_163: G = __r_arr[29];
         let __v_164: G = __r_arr[30];
         let __v_165: G = __r_arr[31];
-        let __v_166: G = G::from_u64(1);
-        let __v_167: G = G::from_u64(1);
-        let __v_168: G = { let __values: [G; 3] = [__v_166, __v_167, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_169: G = G::from_u64(0);
-        let __v_170: G = G::from_u64(1);
-        let __v_171: G = (__v_2 + __v_170);
-        let __v_172: G = { let __values: [G; 32] = [__v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; 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_173: G = __r_arr[0];
-        let __ret: [G; OUT_66] = [__v_173];
+        let __v_166: G = G::from_u64(0);
+        let __v_167: G = G::from_u64(0);
+        let __v_168: G = G::from_u64(1);
+        let __v_169: G = (__v_2 + __v_168);
+        let __v_170: 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_0, __v_166, __v_167, __v_169, __v_3, __v_170, __v_5]; 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_171: G = __r_arr[0];
+        let __ret: [G; OUT_66] = [__v_171];
         record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -7495,18 +7615,24 @@ fn aiur_fn_70(
 ) -> Result<[G; OUT_70], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_70] = [__v_2, __v_3];
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(1);
+        if (__v_1 != __v_2) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_70] = [__v_1, __v_1];
         record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __ret: [G; OUT_70] = [__v_1, __v_2];
+        record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -7792,10 +7918,8 @@ fn aiur_fn_78(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_78] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_78] = [__v_2, __v_0];
         record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -7839,9 +7963,8 @@ fn aiur_fn_78(
         let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_34, __v_36]; 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_37: G = __r_arr[0];
         let __v_38: G = __r_arr[1];
-        let __v_39: G = G::from_u64(0);
-        let __v_40: G = { let __values: [G; 34] = [__v_39, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_37]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_78] = [__v_40, __v_38];
+        let __v_39: G = { let __values: [G; 33] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_37]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_78] = [__v_39, __v_38];
         record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8048,10 +8171,8 @@ fn aiur_fn_80(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_80] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_80] = [__v_2, __v_0];
         record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8067,9 +8188,8 @@ fn aiur_fn_80(
         let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 6] = [__v_11, __v_2, __v_3, __v_4, __v_5, __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_80] = [__v_12, __v_10];
+        let __v_11: G = { let __values: [G; 5] = [__v_2, __v_3, __v_4, __v_5, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_80] = [__v_11, __v_10];
         record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8091,10 +8211,8 @@ fn aiur_fn_81(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_81] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_81] = [__v_2, __v_0];
         record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8107,9 +8225,8 @@ fn aiur_fn_81(
         let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_81] = [__v_9, __v_7];
+        let __v_8: G = { let __values: [G; 2] = [__v_2, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_81] = [__v_8, __v_7];
         record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8157,10 +8274,8 @@ fn aiur_fn_83(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_83] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_83] = [__v_2, __v_0];
         record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8174,9 +8289,8 @@ fn aiur_fn_83(
         let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_4, __v_6]; 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_9, __v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_83] = [__v_10, __v_8];
+        let __v_9: G = { let __values: [G; 3] = [__v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_83] = [__v_9, __v_8];
         record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8570,21 +8684,14 @@ fn aiur_fn_86(
     let __v_54: G = inp[54];
     let __v_55: G = inp[55];
     let __v_56: G = inp[56];
-    let __v_57: G = G::from_u64(0);
-    let __v_58: G = G::from_u64(0);
-    let __v_59: G = G::from_u64(0);
-    let __v_60: G = G::from_u64(0);
-    let __v_61: G = G::from_u64(0);
-    let __v_62: G = G::from_u64(0);
-    let __v_63: G = G::from_u64(0);
-    let __v_64: G = { let __values: [G; 10] = [__v_63, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_65: G = { let __values: [G; 10] = [__v_62, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_64]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_66: G = { let __values: [G; 10] = [__v_61, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_65]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_67: G = { let __values: [G; 10] = [__v_60, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_66]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_68: G = { let __values: [G; 10] = [__v_59, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_67]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_69: G = { let __values: [G; 10] = [__v_58, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_68]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_70: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_69]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_86] = [__v_70];
+    let __v_57: G = { let __values: [G; 9] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_mut(&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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_58: G = { let __values: [G; 9] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_57]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_59: G = { let __values: [G; 9] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_58]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_60: G = { let __values: [G; 9] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_59]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_61: G = { let __values: [G; 9] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_60]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_62: G = { let __values: [G; 9] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_61]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_63: G = { let __values: [G; 9] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_62]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_86] = [__v_63];
     record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -8604,13 +8711,9 @@ fn aiur_fn_87(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 8] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_87] = [__v_4, __v_7, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_87] = [__v_2, __v_3, __v_0];
         record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8685,11 +8788,10 @@ fn aiur_fn_87(
         let __v_67: G = __r_arr[0];
         let __v_68: G = __r_arr[1];
         let __v_69: G = __r_arr[2];
-        let __v_70: G = G::from_u64(0);
-        let __v_71: G = { let __values: [G; 8] = [__v_70, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_67]; 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_70: G = { let __values: [G; 7] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_67]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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_68]; 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_72: G = __r_arr[0];
-        let __ret: [G; OUT_87] = [__v_71, __v_72, __v_69];
+        let __v_71: G = __r_arr[0];
+        let __ret: [G; OUT_87] = [__v_70, __v_71, __v_69];
         record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8749,10 +8851,8 @@ fn aiur_fn_89(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_89] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_89] = [__v_2, __v_0];
         record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -8769,17 +8869,15 @@ fn aiur_fn_89(
           65535u64 => {
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(0);
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_89] = [__v_11, __v_7];
+            let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_89] = [__v_10, __v_7];
             record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_8: G = G::from_u64(0);
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_89] = [__v_10, __v_7];
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_89] = [__v_9, __v_7];
             record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -8878,23 +8976,14 @@ fn aiur_fn_90(
     let __v_69: G = __r_arr[8];
     let __v_70: G = __r_arr[9];
     let __v_71: G = G::from_u64(0);
-    let __v_72: G = G::from_u64(0);
-    let __v_73: G = G::from_u64(0);
-    let __v_74: G = G::from_u64(0);
-    let __v_75: G = G::from_u64(0);
-    let __v_76: G = G::from_u64(0);
-    let __v_77: G = G::from_u64(0);
-    let __v_78: G = G::from_u64(1);
-    let __v_79: G = G::from_u64(1);
-    let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_90] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_87, __v_70];
+    let __v_72: G = { let __values: [G; 9] = [__v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_71]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_73: G = { let __values: [G; 9] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_72]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_74: G = { let __values: [G; 9] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_73]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_75: G = { let __values: [G; 9] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_74]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_76: G = { let __values: [G; 9] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_75]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_77: G = { let __values: [G; 9] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_76]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_78: G = { let __values: [G; 9] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_77]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_90] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_78, __v_70];
     record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -8943,11 +9032,10 @@ fn aiur_fn_91(
     let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_25, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } else { aiur_fn_89(__args, record, io_buffer, __cu)? } };
     let __v_26: G = __r_arr[0];
     let __v_27: G = __r_arr[1];
-    let __v_28: G = G::from_u64(0);
-    let __v_29: G = { let __values: [G; 10] = [__v_28, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_8, __v_29]; 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_30: G = __r_arr[0];
-    let __ret: [G; OUT_91] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_30, __v_20, __v_23, __v_24, __v_26, __v_27];
+    let __v_28: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_8, __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_29: G = __r_arr[0];
+    let __ret: [G; OUT_91] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_29, __v_20, __v_23, __v_24, __v_26, __v_27];
     record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -8968,15 +9056,11 @@ fn aiur_fn_92(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __v_5: G = G::from_u64(0);
-    let __v_6: G = G::from_u64(0);
-    let __v_7: G = G::from_u64(0);
-    let __v_8: G = G::from_u64(0);
-    let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_92] = [__v_12];
+    let __v_5: G = { let __values: [G; 2] = [__v_3, __v_4]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_6: G = { let __values: [G; 2] = [__v_2, __v_5]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_7: G = { let __values: [G; 2] = [__v_1, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_8: G = { let __values: [G; 2] = [__v_0, __v_7]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_92] = [__v_8];
     record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -9710,39 +9794,35 @@ fn aiur_fn_98(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_98] = [__v_5];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_98] = [__v_2];
         record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_5: G = (__v_3 - __v_1);
-        let __v_6: G = G::from_bool((__v_5 == G::ZERO));
-        match __v_6.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = (__v_2 - __v_1);
+        let __v_5: G = G::from_bool((__v_4 == G::ZERO));
+        match __v_5.as_canonical_u64() {
           1u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_98] = [__v_7];
+            let __v_6: G = G::from_u64(1);
+            let __ret: [G; OUT_98] = [__v_6];
             record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_4, __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_7: G = __r_arr[0];
-            let __ret: [G; OUT_98] = [__v_7];
+            let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_3, __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_6: G = __r_arr[0];
+            let __ret: [G; OUT_98] = [__v_6];
             record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -9760,62 +9840,56 @@ fn aiur_fn_99(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_99] = [__v_8];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_99] = [__v_3];
         record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            let __v_9: G = (__v_7 - __v_2);
-            let __v_10: G = G::from_bool((__v_9 == G::ZERO));
-            match __v_10.as_canonical_u64() {
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
+            if (__v_5 != __v_6) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_99] = [__v_5];
+            record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_5: G = __loaded[0];
+            let __v_6: G = __loaded[1];
+            let __v_7: G = (__v_5 - __v_2);
+            let __v_8: G = G::from_bool((__v_7 == G::ZERO));
+            match __v_8.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_5, __v_8, __v_2]; 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_99] = [__v_11];
+                let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_4, __v_6, __v_2]; 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_9: G = __r_arr[0];
+                let __ret: [G; OUT_99] = [__v_9];
                 record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-                let __v_11: G = __loaded[0];
-                let __v_12: G = __loaded[1];
-                let __v_13: G = __loaded[2];
-                let __v_14: G = __loaded[3];
-                let __v_15: G = __loaded[4];
-                let __v_16: G = __loaded[5];
-                let __v_17: G = __loaded[6];
-                let __v_18: G = __loaded[7];
-                let __v_19: G = __loaded[8];
-                let __v_20: G = __loaded[9];
-                match __v_11.as_canonical_u64() {
-                  1u64 => {
-                    let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_5, __v_8, __v_2]; 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_21: G = __r_arr[0];
-                    let __ret: [G; OUT_99] = [__v_21];
+                match __v_3.as_canonical_u64() {
+                  0u64 => {
+                    let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_4, __v_6, __v_2]; 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_9: G = __r_arr[0];
+                    let __ret: [G; OUT_99] = [__v_9];
                     record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __v_21: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_5, __v_8, __v_2]; 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_22: G = __r_arr[0];
-                    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_99] = [__v_23];
+                    let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_4, __v_6, __v_2]; 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_9: G = __r_arr[0];
+                    let __v_10: G = { let __values: [G; 2] = [__v_3, __v_9]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __ret: [G; OUT_99] = [__v_10];
                     record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
@@ -9823,169 +9897,155 @@ fn aiur_fn_99(
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
-}
-
-const INPUT_SIZE_100: usize = 2;
-const IN_100: usize = 2;
-const OUT_100: usize = 11;
-fn aiur_fn_100(
-  inp: [G; IN_100],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_100], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      0u64 => {
-        let __v_12: G = G::from_u64(256);
-        let __v_13: G = (__v_12 * __v_4);
-        let __v_14: G = G::from_u64(65536);
-        let __v_15: G = (__v_14 * __v_5);
-        let __v_16: G = G::from_u64(16777216);
-        let __v_17: G = (__v_16 * __v_6);
-        let __v_18: G = G::from_u64(4294967296);
-        let __v_19: G = (__v_18 * __v_7);
-        let __v_20: G = G::from_u64(1099511627776);
-        let __v_21: G = (__v_20 * __v_8);
-        let __v_22: G = G::from_u64(281474976710656);
-        let __v_23: G = (__v_22 * __v_9);
-        let __v_24: G = G::from_u64(72057594037927936);
-        let __v_25: G = (__v_24 * __v_10);
-        let __v_26: G = (__v_23 + __v_25);
-        let __v_27: G = (__v_21 + __v_26);
-        let __v_28: G = (__v_19 + __v_27);
-        let __v_29: G = (__v_17 + __v_28);
-        let __v_30: G = (__v_15 + __v_29);
-        let __v_31: G = (__v_13 + __v_30);
-        let __v_32: G = (__v_3 + __v_31);
-        let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes();
-        let __v_33: G = G::from_u8(__gb[0]);
-        let __v_34: G = G::from_u8(__gb[1]);
-        let __v_35: G = G::from_u8(__gb[2]);
-        let __v_36: G = G::from_u8(__gb[3]);
-        let __v_37: G = G::from_u8(__gb[4]);
-        let __v_38: G = G::from_u8(__gb[5]);
-        let __v_39: G = G::from_u8(__gb[6]);
-        let __v_40: G = G::from_u8(__gb[7]);
-        if !unconstrained { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_41: G = G::from_u64(1020);
-        let __v_42: G = (__v_40 - __v_41);
-        let __v_43: G = (__v_39 + __v_42);
-        let __v_44: G = (__v_38 + __v_43);
-        let __v_45: G = (__v_37 + __v_44);
-        let __v_46: G = G::from_bool((__v_45 == G::ZERO));
-        let __v_47: G = (__v_35 + __v_36);
-        let __v_48: G = (__v_34 + __v_47);
-        let __v_49: G = (__v_33 + __v_48);
-        let __v_50: G = G::from_bool((__v_49 == G::ZERO));
-        let __v_51: G = G::from_u64(256);
-        let __v_52: G = (__v_51 * __v_34);
-        let __v_53: G = G::from_u64(65536);
-        let __v_54: G = (__v_53 * __v_35);
-        let __v_55: G = G::from_u64(16777216);
-        let __v_56: G = (__v_55 * __v_36);
-        let __v_57: G = G::from_u64(4294967296);
-        let __v_58: G = (__v_57 * __v_37);
-        let __v_59: G = G::from_u64(1099511627776);
-        let __v_60: G = (__v_59 * __v_38);
-        let __v_61: G = G::from_u64(281474976710656);
-        let __v_62: G = (__v_61 * __v_39);
-        let __v_63: G = G::from_u64(72057594037927936);
-        let __v_64: G = (__v_63 * __v_40);
-        let __v_65: G = (__v_62 + __v_64);
-        let __v_66: G = (__v_60 + __v_65);
-        let __v_67: G = (__v_58 + __v_66);
-        let __v_68: G = (__v_56 + __v_67);
-        let __v_69: G = (__v_54 + __v_68);
-        let __v_70: G = (__v_52 + __v_69);
-        let __v_71: G = (__v_33 + __v_70);
-        if (__v_71 != __v_32) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
-        }
-        let __v_72: G = G::from_u64(1);
-        let __v_73: G = G::from_u64(1);
-        let __v_74: G = (__v_73 - __v_50);
-        let __v_75: G = (__v_46 * __v_74);
-        let __v_76: G = (__v_72 - __v_75);
-        let __v_77: G = G::from_u64(1);
-        if (__v_76 != __v_77) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
-        }
-        let __v_78: G = G::from_u64(1);
-        let __ret: [G; OUT_100] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_78];
-        record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __v_15: G = G::from_u64(0);
-            let __v_16: G = G::from_u64(0);
-            let __v_17: G = G::from_u64(0);
-            let __v_18: G = G::from_u64(0);
-            let __v_19: G = G::from_u64(0);
-            let __v_20: G = G::from_u64(0);
-            let __v_21: G = G::from_u64(0);
-            let __v_22: G = G::from_u64(0);
-            let __v_23: G = G::from_u64(0);
-            let __ret: [G; OUT_100] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23];
-            record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+}
+
+const INPUT_SIZE_100: usize = 2;
+const IN_100: usize = 2;
+const OUT_100: usize = 11;
+fn aiur_fn_100(
+  inp: [G; IN_100],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_100], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_13, __v_14]; 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_15: G = __r_arr[0];
-            let __v_16: G = __r_arr[1];
-            let __v_17: G = __r_arr[2];
-            let __v_18: G = __r_arr[3];
-            let __v_19: G = __r_arr[4];
-            let __v_20: G = __r_arr[5];
-            let __v_21: G = __r_arr[6];
-            let __v_22: G = __r_arr[7];
-            let __v_23: G = __r_arr[8];
-            let __v_24: G = __r_arr[9];
-            let __v_25: G = __r_arr[10];
-            let __ret: [G; OUT_100] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+            let __v_2: G = G::from_u64(0);
+            let __v_3: G = G::from_u64(0);
+            let __v_4: G = G::from_u64(0);
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(0);
+            let __v_7: G = G::from_u64(0);
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(0);
+            let __v_10: G = G::from_u64(0);
+            let __ret: [G; OUT_100] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_1, __v_10];
             record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_2: G = __loaded[0];
+            let __v_3: G = __loaded[1];
+            let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2, __v_3]; 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];
+            let __v_5: G = __r_arr[1];
+            let __v_6: G = __r_arr[2];
+            let __v_7: G = __r_arr[3];
+            let __v_8: G = __r_arr[4];
+            let __v_9: G = __r_arr[5];
+            let __v_10: G = __r_arr[6];
+            let __v_11: G = __r_arr[7];
+            let __v_12: G = __r_arr[8];
+            let __v_13: G = __r_arr[9];
+            let __v_14: G = __r_arr[10];
+            let __ret: [G; OUT_100] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14];
+            record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __v_11: G = G::from_u64(256);
+        let __v_12: G = (__v_11 * __v_3);
+        let __v_13: G = G::from_u64(65536);
+        let __v_14: G = (__v_13 * __v_4);
+        let __v_15: G = G::from_u64(16777216);
+        let __v_16: G = (__v_15 * __v_5);
+        let __v_17: G = G::from_u64(4294967296);
+        let __v_18: G = (__v_17 * __v_6);
+        let __v_19: G = G::from_u64(1099511627776);
+        let __v_20: G = (__v_19 * __v_7);
+        let __v_21: G = G::from_u64(281474976710656);
+        let __v_22: G = (__v_21 * __v_8);
+        let __v_23: G = G::from_u64(72057594037927936);
+        let __v_24: G = (__v_23 * __v_9);
+        let __v_25: G = (__v_22 + __v_24);
+        let __v_26: G = (__v_20 + __v_25);
+        let __v_27: G = (__v_18 + __v_26);
+        let __v_28: G = (__v_16 + __v_27);
+        let __v_29: G = (__v_14 + __v_28);
+        let __v_30: G = (__v_12 + __v_29);
+        let __v_31: G = (__v_2 + __v_30);
+        let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes();
+        let __v_32: G = G::from_u8(__gb[0]);
+        let __v_33: G = G::from_u8(__gb[1]);
+        let __v_34: G = G::from_u8(__gb[2]);
+        let __v_35: G = G::from_u8(__gb[3]);
+        let __v_36: G = G::from_u8(__gb[4]);
+        let __v_37: G = G::from_u8(__gb[5]);
+        let __v_38: G = G::from_u8(__gb[6]);
+        let __v_39: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_32; let __vj = __v_33; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_34; let __vj = __v_35; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_36; let __vj = __v_37; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_38; let __vj = __v_39; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_40: G = G::from_u64(1020);
+        let __v_41: G = (__v_39 - __v_40);
+        let __v_42: G = (__v_38 + __v_41);
+        let __v_43: G = (__v_37 + __v_42);
+        let __v_44: G = (__v_36 + __v_43);
+        let __v_45: G = G::from_bool((__v_44 == G::ZERO));
+        let __v_46: G = (__v_34 + __v_35);
+        let __v_47: G = (__v_33 + __v_46);
+        let __v_48: G = (__v_32 + __v_47);
+        let __v_49: G = G::from_bool((__v_48 == G::ZERO));
+        let __v_50: G = G::from_u64(256);
+        let __v_51: G = (__v_50 * __v_33);
+        let __v_52: G = G::from_u64(65536);
+        let __v_53: G = (__v_52 * __v_34);
+        let __v_54: G = G::from_u64(16777216);
+        let __v_55: G = (__v_54 * __v_35);
+        let __v_56: G = G::from_u64(4294967296);
+        let __v_57: G = (__v_56 * __v_36);
+        let __v_58: G = G::from_u64(1099511627776);
+        let __v_59: G = (__v_58 * __v_37);
+        let __v_60: G = G::from_u64(281474976710656);
+        let __v_61: G = (__v_60 * __v_38);
+        let __v_62: G = G::from_u64(72057594037927936);
+        let __v_63: G = (__v_62 * __v_39);
+        let __v_64: G = (__v_61 + __v_63);
+        let __v_65: G = (__v_59 + __v_64);
+        let __v_66: G = (__v_57 + __v_65);
+        let __v_67: G = (__v_55 + __v_66);
+        let __v_68: G = (__v_53 + __v_67);
+        let __v_69: G = (__v_51 + __v_68);
+        let __v_70: G = (__v_32 + __v_69);
+        if (__v_70 != __v_31) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
+        }
+        let __v_71: G = G::from_u64(1);
+        let __v_72: G = G::from_u64(1);
+        let __v_73: G = (__v_72 - __v_49);
+        let __v_74: G = (__v_45 * __v_73);
+        let __v_75: G = (__v_71 - __v_74);
+        let __v_76: G = G::from_u64(1);
+        if (__v_75 != __v_76) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_76.as_canonical_u64(), msg: None });
+        }
+        let __v_77: G = G::from_u64(1);
+        let __ret: [G; OUT_100] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_10, __v_1, __v_77];
+        record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -10021,7 +10081,7 @@ fn aiur_fn_101(
     let __v_16: G = __r_arr[10];
     match __v_16.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_17: G = __loaded[0];
         let __v_18: G = __loaded[1];
         let __v_19: G = __loaded[2];
@@ -10046,40 +10106,40 @@ fn aiur_fn_101(
                                   0u64 => {
                                     match __v_24.as_canonical_u64() {
                                       0u64 => {
-                                        let __v_25: G = G::from_u64(0);
-                                        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-                                        let __v_26: G = __loaded[0];
-                                        let __v_27: G = __loaded[1];
-                                        let __v_28: G = __loaded[2];
-                                        let __v_29: G = __loaded[3];
-                                        let __v_30: G = __loaded[4];
-                                        let __v_31: G = __loaded[5];
-                                        let __v_32: G = __loaded[6];
-                                        let __v_33: G = __loaded[7];
-                                        let __v_34: G = __loaded[8];
-                                        let __v_35: G = __loaded[9];
-                                        let __v_36: G = __loaded[10];
-                                        let __v_37: G = __loaded[11];
-                                        let __v_38: G = __loaded[12];
-                                        let __v_39: G = __loaded[13];
-                                        let __v_40: G = __loaded[14];
-                                        let __v_41: G = __loaded[15];
-                                        let __v_42: G = __loaded[16];
-                                        let __v_43: G = __loaded[17];
-                                        let __v_44: G = __loaded[18];
-                                        let __v_45: G = __loaded[19];
-                                        let __v_46: G = __loaded[20];
-                                        let __v_47: G = __loaded[21];
-                                        let __v_48: G = __loaded[22];
-                                        let __v_49: G = __loaded[23];
-                                        let __v_50: G = __loaded[24];
-                                        let __v_51: G = __loaded[25];
-                                        let __v_52: G = __loaded[26];
-                                        let __v_53: G = __loaded[27];
-                                        let __v_54: G = __loaded[28];
-                                        let __v_55: G = __loaded[29];
-                                        let __v_56: G = __loaded[30];
-                                        let __v_57: G = __loaded[31];
+                                        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+                                        let __v_25: G = __loaded[0];
+                                        let __v_26: G = __loaded[1];
+                                        let __v_27: G = __loaded[2];
+                                        let __v_28: G = __loaded[3];
+                                        let __v_29: G = __loaded[4];
+                                        let __v_30: G = __loaded[5];
+                                        let __v_31: G = __loaded[6];
+                                        let __v_32: G = __loaded[7];
+                                        let __v_33: G = __loaded[8];
+                                        let __v_34: G = __loaded[9];
+                                        let __v_35: G = __loaded[10];
+                                        let __v_36: G = __loaded[11];
+                                        let __v_37: G = __loaded[12];
+                                        let __v_38: G = __loaded[13];
+                                        let __v_39: G = __loaded[14];
+                                        let __v_40: G = __loaded[15];
+                                        let __v_41: G = __loaded[16];
+                                        let __v_42: G = __loaded[17];
+                                        let __v_43: G = __loaded[18];
+                                        let __v_44: G = __loaded[19];
+                                        let __v_45: G = __loaded[20];
+                                        let __v_46: G = __loaded[21];
+                                        let __v_47: G = __loaded[22];
+                                        let __v_48: G = __loaded[23];
+                                        let __v_49: G = __loaded[24];
+                                        let __v_50: G = __loaded[25];
+                                        let __v_51: G = __loaded[26];
+                                        let __v_52: G = __loaded[27];
+                                        let __v_53: G = __loaded[28];
+                                        let __v_54: G = __loaded[29];
+                                        let __v_55: G = __loaded[30];
+                                        let __v_56: G = __loaded[31];
+                                        let __v_57: G = G::from_u64(0);
                                         let __v_58: G = G::from_u64(0);
                                         let __v_59: G = G::from_u64(0);
                                         let __v_60: G = G::from_u64(0);
@@ -10143,53 +10203,52 @@ fn aiur_fn_101(
                                         let __v_118: G = G::from_u64(0);
                                         let __v_119: G = G::from_u64(0);
                                         let __v_120: G = G::from_u64(0);
-                                        let __v_121: G = G::from_u64(0);
-                                        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-                                        let __v_122: G = __loaded[0];
-                                        let __v_123: G = __loaded[1];
-                                        let __v_124: G = __loaded[2];
-                                        let __v_125: G = __loaded[3];
-                                        let __v_126: G = __loaded[4];
-                                        let __v_127: G = __loaded[5];
-                                        let __v_128: G = __loaded[6];
-                                        let __v_129: G = __loaded[7];
-                                        let __v_130: G = G::from_u64(0);
-                                        let __v_131: G = G::from_u64(11);
-                                        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_132: G = __r_arr[0];
-                                        let __v_133: G = __r_arr[1];
-                                        let __v_134: G = __r_arr[2];
-                                        let __v_135: G = __r_arr[3];
-                                        let __v_136: G = __r_arr[4];
-                                        let __v_137: G = __r_arr[5];
-                                        let __v_138: G = __r_arr[6];
-                                        let __v_139: G = __r_arr[7];
-                                        let __v_140: G = __r_arr[8];
-                                        let __v_141: G = __r_arr[9];
-                                        let __v_142: G = __r_arr[10];
-                                        let __v_143: G = __r_arr[11];
-                                        let __v_144: G = __r_arr[12];
-                                        let __v_145: G = __r_arr[13];
-                                        let __v_146: G = __r_arr[14];
-                                        let __v_147: G = __r_arr[15];
-                                        let __v_148: G = __r_arr[16];
-                                        let __v_149: G = __r_arr[17];
-                                        let __v_150: G = __r_arr[18];
-                                        let __v_151: G = __r_arr[19];
-                                        let __v_152: G = __r_arr[20];
-                                        let __v_153: G = __r_arr[21];
-                                        let __v_154: G = __r_arr[22];
-                                        let __v_155: G = __r_arr[23];
-                                        let __v_156: G = __r_arr[24];
-                                        let __v_157: G = __r_arr[25];
-                                        let __v_158: G = __r_arr[26];
-                                        let __v_159: G = __r_arr[27];
-                                        let __v_160: G = __r_arr[28];
-                                        let __v_161: G = __r_arr[29];
-                                        let __v_162: G = __r_arr[30];
-                                        let __v_163: G = __r_arr[31];
-                                        let __v_164: G = { let __values: [G; 34] = [__v_25, __v_5, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_101] = [__v_164];
+                                        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                                        let __v_121: G = __loaded[0];
+                                        let __v_122: G = __loaded[1];
+                                        let __v_123: G = __loaded[2];
+                                        let __v_124: G = __loaded[3];
+                                        let __v_125: G = __loaded[4];
+                                        let __v_126: G = __loaded[5];
+                                        let __v_127: G = __loaded[6];
+                                        let __v_128: G = __loaded[7];
+                                        let __v_129: G = G::from_u64(0);
+                                        let __v_130: G = G::from_u64(11);
+                                        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130]; 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_131: G = __r_arr[0];
+                                        let __v_132: G = __r_arr[1];
+                                        let __v_133: G = __r_arr[2];
+                                        let __v_134: G = __r_arr[3];
+                                        let __v_135: G = __r_arr[4];
+                                        let __v_136: G = __r_arr[5];
+                                        let __v_137: G = __r_arr[6];
+                                        let __v_138: G = __r_arr[7];
+                                        let __v_139: G = __r_arr[8];
+                                        let __v_140: G = __r_arr[9];
+                                        let __v_141: G = __r_arr[10];
+                                        let __v_142: G = __r_arr[11];
+                                        let __v_143: G = __r_arr[12];
+                                        let __v_144: G = __r_arr[13];
+                                        let __v_145: G = __r_arr[14];
+                                        let __v_146: G = __r_arr[15];
+                                        let __v_147: G = __r_arr[16];
+                                        let __v_148: G = __r_arr[17];
+                                        let __v_149: G = __r_arr[18];
+                                        let __v_150: G = __r_arr[19];
+                                        let __v_151: G = __r_arr[20];
+                                        let __v_152: G = __r_arr[21];
+                                        let __v_153: G = __r_arr[22];
+                                        let __v_154: G = __r_arr[23];
+                                        let __v_155: G = __r_arr[24];
+                                        let __v_156: G = __r_arr[25];
+                                        let __v_157: G = __r_arr[26];
+                                        let __v_158: G = __r_arr[27];
+                                        let __v_159: G = __r_arr[28];
+                                        let __v_160: G = __r_arr[29];
+                                        let __v_161: G = __r_arr[30];
+                                        let __v_162: G = __r_arr[31];
+                                        let __v_163: G = { let __values: [G; 33] = [__v_5, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __ret: [G; OUT_101] = [__v_163];
                                         record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
@@ -10343,220 +10402,203 @@ fn aiur_fn_101(
         let __v_100: G = (__v_27 + __v_99);
         let __v_101: G = (__v_16 + __v_100);
         let __v_102: G = (__v_94 * __v_101);
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_103: G = __loaded[0];
-        let __v_104: G = __loaded[1];
-        let __v_105: G = __loaded[2];
-        let __v_106: G = __loaded[3];
-        let __v_107: G = __loaded[4];
-        let __v_108: G = __loaded[5];
-        let __v_109: G = __loaded[6];
-        let __v_110: G = __loaded[7];
-        let __v_111: G = __loaded[8];
-        let __v_112: G = __loaded[9];
-        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() {
-  1u64 => {
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_113: G = __loaded[0];
-    let __v_114: G = __loaded[1];
-    let __v_115: G = __loaded[2];
-    match __v_113.as_canonical_u64() {
-      1u64 => {
-        let __v_116: G = G::from_u64(1);
-        break '__mc_0 [__v_116];
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_91.as_canonical_u64() {
+  0u64 => {
+    match __v_92.as_canonical_u64() {
+      0u64 => {
+        let __v_103: G = G::from_u64(1);
+        break '__mc_0 [__v_103];
       },
       _ => {
-        let __v_116: G = G::from_u64(0);
-        break '__mc_0 [__v_116];
+        let __v_103: G = G::from_u64(0);
+        break '__mc_0 [__v_103];
       },
     }
   },
   _ => {
-    let __v_113: G = G::from_u64(0);
-    break '__mc_0 [__v_113];
+    let __v_103: G = G::from_u64(0);
+    break '__mc_0 [__v_103];
   },
 }
  };
-        let __v_113: G = __mc_out___mc_0[0];
-        let __v_114: G = G::from_u64(15);
-        let __v_115: G = (__v_2 - __v_114);
-        let __v_116: G = G::from_bool((__v_115 == G::ZERO));
-        let __v_117: G = G::from_bool((__v_2 == G::ZERO));
-        let __v_118: G = (__v_113 * __v_116);
-        let __v_119: G = (__v_116 - __v_118);
-        let __v_120: G = (__v_113 + __v_119);
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_121: G = __loaded[0];
-        let __v_122: G = __loaded[1];
-        let __v_123: G = __loaded[2];
-        let __v_124: G = __loaded[3];
-        let __v_125: G = __loaded[4];
-        let __v_126: G = __loaded[5];
-        let __v_127: G = __loaded[6];
-        let __v_128: G = __loaded[7];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
-        let __v_129: G = __r_arr[0];
-        let __v_130: G = (__v_113 * __v_129);
-        let __v_131: G = G::from_u64(2);
-        let __v_132: G = (__v_131 * __v_120);
-        let __v_133: G = G::from_u64(8);
-        let __v_134: G = (__v_133 * __v_130);
-        let __v_135: G = (__v_132 + __v_134);
-        let __v_136: G = (__v_117 + __v_135);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_137: G = __loaded[0];
-        let __v_138: G = __loaded[1];
-        let __v_139: G = __loaded[2];
-        let __v_140: G = __loaded[3];
-        let __v_141: G = __loaded[4];
-        let __v_142: G = __loaded[5];
-        let __v_143: G = __loaded[6];
-        let __v_144: G = __loaded[7];
-        let __v_145: G = __loaded[8];
-        let __v_146: G = __loaded[9];
-        let __v_147: G = __loaded[10];
-        let __v_148: G = __loaded[11];
-        let __v_149: G = __loaded[12];
-        let __v_150: G = __loaded[13];
-        let __v_151: G = __loaded[14];
-        let __v_152: G = __loaded[15];
-        let __v_153: G = __loaded[16];
-        let __v_154: G = __loaded[17];
-        let __v_155: G = __loaded[18];
-        let __v_156: G = __loaded[19];
-        let __v_157: G = __loaded[20];
-        let __v_158: G = __loaded[21];
-        let __v_159: G = __loaded[22];
-        let __v_160: G = __loaded[23];
-        let __v_161: G = __loaded[24];
-        let __v_162: G = __loaded[25];
-        let __v_163: G = __loaded[26];
-        let __v_164: G = __loaded[27];
-        let __v_165: G = __loaded[28];
-        let __v_166: G = __loaded[29];
-        let __v_167: G = __loaded[30];
-        let __v_168: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-        let __v_169: G = __loaded[0];
-        let __v_170: G = __loaded[1];
-        let __v_171: G = __loaded[2];
-        let __v_172: G = __loaded[3];
-        let __v_173: G = __loaded[4];
-        let __v_174: G = __loaded[5];
-        let __v_175: G = __loaded[6];
-        let __v_176: G = __loaded[7];
-        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_102, __v_136]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_177: G = __r_arr[0];
-        let __v_178: G = __r_arr[1];
-        let __v_179: G = __r_arr[2];
-        let __v_180: G = __r_arr[3];
-        let __v_181: G = __r_arr[4];
-        let __v_182: G = __r_arr[5];
-        let __v_183: G = __r_arr[6];
-        let __v_184: G = __r_arr[7];
-        let __v_185: G = __r_arr[8];
-        let __v_186: G = __r_arr[9];
-        let __v_187: G = __r_arr[10];
-        let __v_188: G = __r_arr[11];
-        let __v_189: G = __r_arr[12];
-        let __v_190: G = __r_arr[13];
-        let __v_191: G = __r_arr[14];
-        let __v_192: G = __r_arr[15];
-        let __v_193: G = __r_arr[16];
-        let __v_194: G = __r_arr[17];
-        let __v_195: G = __r_arr[18];
-        let __v_196: G = __r_arr[19];
-        let __v_197: G = __r_arr[20];
-        let __v_198: G = __r_arr[21];
-        let __v_199: G = __r_arr[22];
-        let __v_200: G = __r_arr[23];
-        let __v_201: G = __r_arr[24];
-        let __v_202: G = __r_arr[25];
-        let __v_203: G = __r_arr[26];
-        let __v_204: G = __r_arr[27];
-        let __v_205: G = __r_arr[28];
-        let __v_206: G = __r_arr[29];
-        let __v_207: G = __r_arr[30];
-        let __v_208: G = __r_arr[31];
-        match __v_113.as_canonical_u64() {
+        let __v_103: G = __mc_out___mc_0[0];
+        let __v_104: G = G::from_u64(15);
+        let __v_105: G = (__v_2 - __v_104);
+        let __v_106: G = G::from_bool((__v_105 == G::ZERO));
+        let __v_107: G = G::from_bool((__v_2 == G::ZERO));
+        let __v_108: G = (__v_103 * __v_106);
+        let __v_109: G = (__v_106 - __v_108);
+        let __v_110: G = (__v_103 + __v_109);
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_111: G = __loaded[0];
+        let __v_112: G = __loaded[1];
+        let __v_113: G = __loaded[2];
+        let __v_114: G = __loaded[3];
+        let __v_115: G = __loaded[4];
+        let __v_116: G = __loaded[5];
+        let __v_117: G = __loaded[6];
+        let __v_118: G = __loaded[7];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_119: G = __r_arr[0];
+        let __v_120: G = (__v_103 * __v_119);
+        let __v_121: G = G::from_u64(2);
+        let __v_122: G = (__v_121 * __v_110);
+        let __v_123: G = G::from_u64(8);
+        let __v_124: G = (__v_123 * __v_120);
+        let __v_125: G = (__v_122 + __v_124);
+        let __v_126: G = (__v_107 + __v_125);
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_127: G = __loaded[0];
+        let __v_128: G = __loaded[1];
+        let __v_129: G = __loaded[2];
+        let __v_130: G = __loaded[3];
+        let __v_131: G = __loaded[4];
+        let __v_132: G = __loaded[5];
+        let __v_133: G = __loaded[6];
+        let __v_134: G = __loaded[7];
+        let __v_135: G = __loaded[8];
+        let __v_136: G = __loaded[9];
+        let __v_137: G = __loaded[10];
+        let __v_138: G = __loaded[11];
+        let __v_139: G = __loaded[12];
+        let __v_140: G = __loaded[13];
+        let __v_141: G = __loaded[14];
+        let __v_142: G = __loaded[15];
+        let __v_143: G = __loaded[16];
+        let __v_144: G = __loaded[17];
+        let __v_145: G = __loaded[18];
+        let __v_146: G = __loaded[19];
+        let __v_147: G = __loaded[20];
+        let __v_148: G = __loaded[21];
+        let __v_149: G = __loaded[22];
+        let __v_150: G = __loaded[23];
+        let __v_151: G = __loaded[24];
+        let __v_152: G = __loaded[25];
+        let __v_153: G = __loaded[26];
+        let __v_154: G = __loaded[27];
+        let __v_155: G = __loaded[28];
+        let __v_156: G = __loaded[29];
+        let __v_157: G = __loaded[30];
+        let __v_158: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_159: G = __loaded[0];
+        let __v_160: G = __loaded[1];
+        let __v_161: G = __loaded[2];
+        let __v_162: G = __loaded[3];
+        let __v_163: G = __loaded[4];
+        let __v_164: G = __loaded[5];
+        let __v_165: G = __loaded[6];
+        let __v_166: G = __loaded[7];
+        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__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, __v_157, __v_158, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_102, __v_126]; 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_167: G = __r_arr[0];
+        let __v_168: G = __r_arr[1];
+        let __v_169: G = __r_arr[2];
+        let __v_170: G = __r_arr[3];
+        let __v_171: G = __r_arr[4];
+        let __v_172: G = __r_arr[5];
+        let __v_173: G = __r_arr[6];
+        let __v_174: G = __r_arr[7];
+        let __v_175: G = __r_arr[8];
+        let __v_176: G = __r_arr[9];
+        let __v_177: G = __r_arr[10];
+        let __v_178: G = __r_arr[11];
+        let __v_179: G = __r_arr[12];
+        let __v_180: G = __r_arr[13];
+        let __v_181: G = __r_arr[14];
+        let __v_182: G = __r_arr[15];
+        let __v_183: G = __r_arr[16];
+        let __v_184: G = __r_arr[17];
+        let __v_185: G = __r_arr[18];
+        let __v_186: G = __r_arr[19];
+        let __v_187: G = __r_arr[20];
+        let __v_188: G = __r_arr[21];
+        let __v_189: G = __r_arr[22];
+        let __v_190: G = __r_arr[23];
+        let __v_191: G = __r_arr[24];
+        let __v_192: G = __r_arr[25];
+        let __v_193: G = __r_arr[26];
+        let __v_194: G = __r_arr[27];
+        let __v_195: G = __r_arr[28];
+        let __v_196: G = __r_arr[29];
+        let __v_197: G = __r_arr[30];
+        let __v_198: G = __r_arr[31];
+        match __v_103.as_canonical_u64() {
           1u64 => {
-            let __v_209: G = G::from_u64(0);
-            let __v_210: G = { let __values: [G; 34] = [__v_209, __v_5, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_101] = [__v_210];
+            let __v_199: G = { let __values: [G; 33] = [__v_5, __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_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_101] = [__v_199];
             record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            match __v_116.as_canonical_u64() {
+            match __v_106.as_canonical_u64() {
               1u64 => {
-                let __v_209: G = G::from_u64(103);
-                let __v_210: G = G::from_u64(230);
-                let __v_211: G = G::from_u64(9);
-                let __v_212: G = G::from_u64(106);
-                let __v_213: G = G::from_u64(133);
-                let __v_214: G = G::from_u64(174);
-                let __v_215: G = G::from_u64(103);
-                let __v_216: G = G::from_u64(187);
-                let __v_217: G = G::from_u64(114);
-                let __v_218: G = G::from_u64(243);
-                let __v_219: G = G::from_u64(110);
-                let __v_220: G = G::from_u64(60);
-                let __v_221: G = G::from_u64(58);
-                let __v_222: G = G::from_u64(245);
-                let __v_223: G = G::from_u64(79);
-                let __v_224: G = G::from_u64(165);
-                let __v_225: G = G::from_u64(127);
-                let __v_226: G = G::from_u64(82);
-                let __v_227: G = G::from_u64(14);
-                let __v_228: G = G::from_u64(81);
-                let __v_229: G = G::from_u64(140);
-                let __v_230: G = G::from_u64(104);
-                let __v_231: G = G::from_u64(5);
-                let __v_232: G = G::from_u64(155);
-                let __v_233: G = G::from_u64(171);
-                let __v_234: G = G::from_u64(217);
-                let __v_235: G = G::from_u64(131);
-                let __v_236: G = G::from_u64(31);
-                let __v_237: G = G::from_u64(25);
-                let __v_238: G = G::from_u64(205);
-                let __v_239: G = G::from_u64(224);
-                let __v_240: G = G::from_u64(91);
-                let __v_241: G = G::from_u64(0);
-                let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-                let __v_242: G = __loaded[0];
-                let __v_243: G = __loaded[1];
-                let __v_244: G = __loaded[2];
-                let __v_245: G = __loaded[3];
-                let __v_246: G = __loaded[4];
-                let __v_247: G = __loaded[5];
-                let __v_248: G = __loaded[6];
-                let __v_249: G = __loaded[7];
-                let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249]; let __cu = unconstrained; if let Some(result) = record.function_queries[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__args, record, io_buffer, __cu)? } };
-                let __v_250: G = __r_arr[0];
-                let __v_251: G = __r_arr[1];
-                let __v_252: G = __r_arr[2];
-                let __v_253: G = __r_arr[3];
-                let __v_254: G = __r_arr[4];
-                let __v_255: G = __r_arr[5];
-                let __v_256: G = __r_arr[6];
-                let __v_257: G = __r_arr[7];
-                let __v_258: G = { let __values: [G; 8] = [__v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_259: G = { let __values: [G; 32] = [__v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_260: G = G::from_u64(0);
-                let __v_261: G = { let __values: [G; 34] = [__v_260, __v_5, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_91, __v_92, __v_241, __v_258, __v_259, __v_261]; 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_262: G = __r_arr[0];
-                let __ret: [G; OUT_101] = [__v_262];
+                let __v_199: G = G::from_u64(103);
+                let __v_200: G = G::from_u64(230);
+                let __v_201: G = G::from_u64(9);
+                let __v_202: G = G::from_u64(106);
+                let __v_203: G = G::from_u64(133);
+                let __v_204: G = G::from_u64(174);
+                let __v_205: G = G::from_u64(103);
+                let __v_206: G = G::from_u64(187);
+                let __v_207: G = G::from_u64(114);
+                let __v_208: G = G::from_u64(243);
+                let __v_209: G = G::from_u64(110);
+                let __v_210: G = G::from_u64(60);
+                let __v_211: G = G::from_u64(58);
+                let __v_212: G = G::from_u64(245);
+                let __v_213: G = G::from_u64(79);
+                let __v_214: G = G::from_u64(165);
+                let __v_215: G = G::from_u64(127);
+                let __v_216: G = G::from_u64(82);
+                let __v_217: G = G::from_u64(14);
+                let __v_218: G = G::from_u64(81);
+                let __v_219: G = G::from_u64(140);
+                let __v_220: G = G::from_u64(104);
+                let __v_221: G = G::from_u64(5);
+                let __v_222: G = G::from_u64(155);
+                let __v_223: G = G::from_u64(171);
+                let __v_224: G = G::from_u64(217);
+                let __v_225: G = G::from_u64(131);
+                let __v_226: G = G::from_u64(31);
+                let __v_227: G = G::from_u64(25);
+                let __v_228: G = G::from_u64(205);
+                let __v_229: G = G::from_u64(224);
+                let __v_230: G = G::from_u64(91);
+                let __v_231: G = G::from_u64(0);
+                let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_232: G = __loaded[0];
+                let __v_233: G = __loaded[1];
+                let __v_234: G = __loaded[2];
+                let __v_235: G = __loaded[3];
+                let __v_236: G = __loaded[4];
+                let __v_237: G = __loaded[5];
+                let __v_238: G = __loaded[6];
+                let __v_239: G = __loaded[7];
+                let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__args, record, io_buffer, __cu)? } };
+                let __v_240: G = __r_arr[0];
+                let __v_241: G = __r_arr[1];
+                let __v_242: G = __r_arr[2];
+                let __v_243: G = __r_arr[3];
+                let __v_244: G = __r_arr[4];
+                let __v_245: G = __r_arr[5];
+                let __v_246: G = __r_arr[6];
+                let __v_247: G = __r_arr[7];
+                let __v_248: G = { let __values: [G; 8] = [__v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_249: G = { let __values: [G; 32] = [__v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_250: G = { let __values: [G; 33] = [__v_5, __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_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198]; let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_91, __v_92, __v_231, __v_248, __v_249, __v_250]; 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_251: G = __r_arr[0];
+                let __ret: [G; OUT_101] = [__v_251];
                 record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_209: G = G::from_u64(1);
-                let __v_210: G = (__v_2 + __v_209);
-                let __v_211: G = { let __values: [G; 32] = [__v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_91, __v_92, __v_210, __v_3, __v_211, __v_5]; 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_212: G = __r_arr[0];
-                let __ret: [G; OUT_101] = [__v_212];
+                let __v_199: G = G::from_u64(1);
+                let __v_200: G = (__v_2 + __v_199);
+                let __v_201: G = { let __values: [G; 32] = [__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_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_91, __v_92, __v_200, __v_3, __v_201, __v_5]; 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_202: G = __r_arr[0];
+                let __ret: [G; OUT_101] = [__v_202];
                 record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -10611,9 +10653,9 @@ fn aiur_fn_102(
     let __v_30: G = G::from_u64(205);
     let __v_31: G = G::from_u64(224);
     let __v_32: G = G::from_u64(91);
-    let __v_33: G = G::from_u64(1);
-    let __v_34: G = G::from_u64(1);
-    let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_33: G = G::from_u64(0);
+    let __v_34: G = G::from_u64(0);
+    let __v_35: G = G::from_u64(0);
     let __v_36: G = G::from_u64(0);
     let __v_37: G = G::from_u64(0);
     let __v_38: G = G::from_u64(0);
@@ -10621,84 +10663,45 @@ fn aiur_fn_102(
     let __v_40: G = G::from_u64(0);
     let __v_41: G = G::from_u64(0);
     let __v_42: G = G::from_u64(0);
-    let __v_43: G = G::from_u64(0);
-    let __v_44: G = G::from_u64(0);
-    let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_47: G = G::from_u64(1);
-    let __v_48: G = G::from_u64(1);
-    let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; 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_50: G = __r_arr[0];
-    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-    let __v_51: G = __loaded[0];
-    let __v_52: G = __loaded[1];
-    let __v_53: G = __loaded[2];
-    let __v_54: G = __loaded[3];
-    let __v_55: G = __loaded[4];
-    let __v_56: G = __loaded[5];
-    let __v_57: G = __loaded[6];
-    let __v_58: G = __loaded[7];
-    let __v_59: G = __loaded[8];
-    let __v_60: G = __loaded[9];
-    let __v_61: G = __loaded[10];
-    let __v_62: G = __loaded[11];
-    let __v_63: G = __loaded[12];
-    let __v_64: G = __loaded[13];
-    let __v_65: G = __loaded[14];
-    let __v_66: G = __loaded[15];
-    let __v_67: G = __loaded[16];
-    let __v_68: G = __loaded[17];
-    let __v_69: G = __loaded[18];
-    let __v_70: G = __loaded[19];
-    let __v_71: G = __loaded[20];
-    let __v_72: G = __loaded[21];
-    let __v_73: G = __loaded[22];
-    let __v_74: G = __loaded[23];
-    let __v_75: G = __loaded[24];
-    let __v_76: G = __loaded[25];
-    let __v_77: G = __loaded[26];
-    let __v_78: G = __loaded[27];
-    let __v_79: G = __loaded[28];
-    let __v_80: G = __loaded[29];
-    let __v_81: G = __loaded[30];
-    let __v_82: G = __loaded[31];
-    let __v_83: G = __loaded[32];
-    let __v_84: G = __loaded[33];
-    let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_85: G = __r_arr[0];
-    let __v_86: G = __r_arr[1];
-    let __v_87: G = __r_arr[2];
-    let __v_88: G = __r_arr[3];
-    let __v_89: G = __r_arr[4];
-    let __v_90: G = __r_arr[5];
-    let __v_91: G = __r_arr[6];
-    let __v_92: G = __r_arr[7];
-    let __v_93: G = __r_arr[8];
-    let __v_94: G = __r_arr[9];
-    let __v_95: G = __r_arr[10];
-    let __v_96: G = __r_arr[11];
-    let __v_97: G = __r_arr[12];
-    let __v_98: G = __r_arr[13];
-    let __v_99: G = __r_arr[14];
-    let __v_100: G = __r_arr[15];
-    let __v_101: G = __r_arr[16];
-    let __v_102: G = __r_arr[17];
-    let __v_103: G = __r_arr[18];
-    let __v_104: G = __r_arr[19];
-    let __v_105: G = __r_arr[20];
-    let __v_106: G = __r_arr[21];
-    let __v_107: G = __r_arr[22];
-    let __v_108: G = __r_arr[23];
-    let __v_109: G = __r_arr[24];
-    let __v_110: G = __r_arr[25];
-    let __v_111: G = __r_arr[26];
-    let __v_112: G = __r_arr[27];
-    let __v_113: G = __r_arr[28];
-    let __v_114: G = __r_arr[29];
-    let __v_115: G = __r_arr[30];
-    let __v_116: G = __r_arr[31];
-    let __ret: [G; OUT_102] = [__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];
+    let __v_43: G = { let __values: [G; 8] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_44: 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_45: G = G::from_u64(0);
+    let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_33, __v_0, __v_34, __v_43, __v_44, __v_45]; 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_46: G = __r_arr[0];
+    let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_46]; 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_47: G = __r_arr[0];
+    let __v_48: G = __r_arr[1];
+    let __v_49: G = __r_arr[2];
+    let __v_50: G = __r_arr[3];
+    let __v_51: G = __r_arr[4];
+    let __v_52: G = __r_arr[5];
+    let __v_53: G = __r_arr[6];
+    let __v_54: G = __r_arr[7];
+    let __v_55: G = __r_arr[8];
+    let __v_56: G = __r_arr[9];
+    let __v_57: G = __r_arr[10];
+    let __v_58: G = __r_arr[11];
+    let __v_59: G = __r_arr[12];
+    let __v_60: G = __r_arr[13];
+    let __v_61: G = __r_arr[14];
+    let __v_62: G = __r_arr[15];
+    let __v_63: G = __r_arr[16];
+    let __v_64: G = __r_arr[17];
+    let __v_65: G = __r_arr[18];
+    let __v_66: G = __r_arr[19];
+    let __v_67: G = __r_arr[20];
+    let __v_68: G = __r_arr[21];
+    let __v_69: G = __r_arr[22];
+    let __v_70: G = __r_arr[23];
+    let __v_71: G = __r_arr[24];
+    let __v_72: G = __r_arr[25];
+    let __v_73: G = __r_arr[26];
+    let __v_74: G = __r_arr[27];
+    let __v_75: G = __r_arr[28];
+    let __v_76: G = __r_arr[29];
+    let __v_77: G = __r_arr[30];
+    let __v_78: G = __r_arr[31];
+    let __ret: [G; OUT_102] = [__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];
     record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -10930,29 +10933,25 @@ fn aiur_fn_105(
 ) -> Result<[G; OUT_105], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_105] = [__v_4];
-        record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_4: G = G::from_u64(2);
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_3]; 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_5: G = __r_arr[0];
-        let __v_6: G = (__v_4 * __v_5);
-        let __v_7: G = (__v_2 + __v_6);
-        let __ret: [G; OUT_105] = [__v_7];
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_105] = [__v_1];
         record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = G::from_u64(2);
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_2]; 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_4: G = __r_arr[0];
+        let __v_5: G = (__v_3 * __v_4);
+        let __v_6: G = (__v_1 + __v_5);
+        let __ret: [G; OUT_105] = [__v_6];
+        record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -11005,170 +11004,172 @@ fn aiur_fn_106(
     let __v_34: G = inp[34];
     let __v_35: G = inp[35];
     let __v_36: G = inp[36];
-    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-    let __v_37: G = __loaded[0];
-    let __v_38: G = __loaded[1];
-    let __v_39: G = __loaded[2];
-    let __v_40: G = __loaded[3];
-    let __v_41: G = __loaded[4];
-    let __v_42: G = __loaded[5];
-    let __v_43: G = __loaded[6];
-    let __v_44: G = __loaded[7];
-    let __v_45: G = __loaded[8];
-    let __v_46: G = __loaded[9];
-    let __v_47: G = __loaded[10];
-    let __v_48: G = __loaded[11];
-    let __v_49: G = __loaded[12];
-    let __v_50: G = __loaded[13];
-    let __v_51: G = __loaded[14];
-    let __v_52: G = __loaded[15];
-    let __v_53: G = __loaded[16];
-    let __v_54: G = __loaded[17];
-    let __v_55: G = __loaded[18];
-    let __v_56: G = __loaded[19];
-    let __v_57: G = __loaded[20];
-    let __v_58: G = __loaded[21];
-    let __v_59: G = __loaded[22];
-    let __v_60: G = __loaded[23];
-    let __v_61: G = __loaded[24];
-    let __v_62: G = __loaded[25];
-    let __v_63: G = __loaded[26];
-    let __v_64: G = __loaded[27];
-    let __v_65: G = __loaded[28];
-    let __v_66: G = __loaded[29];
-    let __v_67: G = __loaded[30];
-    let __v_68: G = __loaded[31];
-    let __v_69: G = __loaded[32];
-    let __v_70: G = __loaded[33];
-    match __v_37.as_canonical_u64() {
-      1u64 => {
+    match __v_34.as_canonical_u64() {
+      0u64 => {
         let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_35]; 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_71: G = __r_arr[0];
-        let __ret: [G; OUT_106] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_71];
+        let __v_37: G = __r_arr[0];
+        let __ret: [G; OUT_106] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_37];
         record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_35.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_71: G = __loaded[0];
-        let __v_72: G = __loaded[1];
-        let __v_73: G = __loaded[2];
-        match __v_71.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 33] = { let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 33 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 33] = __args[..33].try_into().unwrap(); __arr };
+        let __v_37: G = __loaded[0];
+        let __v_38: G = __loaded[1];
+        let __v_39: G = __loaded[2];
+        let __v_40: G = __loaded[3];
+        let __v_41: G = __loaded[4];
+        let __v_42: G = __loaded[5];
+        let __v_43: G = __loaded[6];
+        let __v_44: G = __loaded[7];
+        let __v_45: G = __loaded[8];
+        let __v_46: G = __loaded[9];
+        let __v_47: G = __loaded[10];
+        let __v_48: G = __loaded[11];
+        let __v_49: G = __loaded[12];
+        let __v_50: G = __loaded[13];
+        let __v_51: G = __loaded[14];
+        let __v_52: G = __loaded[15];
+        let __v_53: G = __loaded[16];
+        let __v_54: G = __loaded[17];
+        let __v_55: G = __loaded[18];
+        let __v_56: G = __loaded[19];
+        let __v_57: G = __loaded[20];
+        let __v_58: G = __loaded[21];
+        let __v_59: G = __loaded[22];
+        let __v_60: G = __loaded[23];
+        let __v_61: G = __loaded[24];
+        let __v_62: G = __loaded[25];
+        let __v_63: G = __loaded[26];
+        let __v_64: G = __loaded[27];
+        let __v_65: G = __loaded[28];
+        let __v_66: G = __loaded[29];
+        let __v_67: G = __loaded[30];
+        let __v_68: G = __loaded[31];
+        let __v_69: G = __loaded[32];
+        match __v_35.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_72, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_74: G = __r_arr[0];
-            let __v_75: G = __r_arr[1];
-            let __v_76: G = __r_arr[2];
-            let __v_77: G = __r_arr[3];
-            let __v_78: G = __r_arr[4];
-            let __v_79: G = __r_arr[5];
-            let __v_80: G = __r_arr[6];
-            let __v_81: G = __r_arr[7];
-            let __v_82: G = __r_arr[8];
-            let __v_83: G = __r_arr[9];
-            let __v_84: G = __r_arr[10];
-            let __v_85: G = __r_arr[11];
-            let __v_86: G = __r_arr[12];
-            let __v_87: G = __r_arr[13];
-            let __v_88: G = __r_arr[14];
-            let __v_89: G = __r_arr[15];
-            let __v_90: G = __r_arr[16];
-            let __v_91: G = __r_arr[17];
-            let __v_92: G = __r_arr[18];
-            let __v_93: G = __r_arr[19];
-            let __v_94: G = __r_arr[20];
-            let __v_95: G = __r_arr[21];
-            let __v_96: G = __r_arr[22];
-            let __v_97: G = __r_arr[23];
-            let __v_98: G = __r_arr[24];
-            let __v_99: G = __r_arr[25];
-            let __v_100: G = __r_arr[26];
-            let __v_101: G = __r_arr[27];
-            let __v_102: G = __r_arr[28];
-            let __v_103: G = __r_arr[29];
-            let __v_104: G = __r_arr[30];
-            let __v_105: G = __r_arr[31];
-            let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_32, __v_33, __v_36, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_106: G = __r_arr[0];
-            let __v_107: G = __r_arr[1];
-            let __v_108: G = __r_arr[2];
-            let __v_109: G = __r_arr[3];
-            let __v_110: G = __r_arr[4];
-            let __v_111: G = __r_arr[5];
-            let __v_112: G = __r_arr[6];
-            let __v_113: G = __r_arr[7];
-            let __v_114: G = __r_arr[8];
-            let __v_115: G = __r_arr[9];
-            let __v_116: G = __r_arr[10];
-            let __v_117: G = __r_arr[11];
-            let __v_118: G = __r_arr[12];
-            let __v_119: G = __r_arr[13];
-            let __v_120: G = __r_arr[14];
-            let __v_121: G = __r_arr[15];
-            let __v_122: G = __r_arr[16];
-            let __v_123: G = __r_arr[17];
-            let __v_124: G = __r_arr[18];
-            let __v_125: G = __r_arr[19];
-            let __v_126: G = __r_arr[20];
-            let __v_127: G = __r_arr[21];
-            let __v_128: G = __r_arr[22];
-            let __v_129: G = __r_arr[23];
-            let __v_130: G = __r_arr[24];
-            let __v_131: G = __r_arr[25];
-            let __v_132: G = __r_arr[26];
-            let __v_133: G = __r_arr[27];
-            let __v_134: G = __r_arr[28];
-            let __v_135: G = __r_arr[29];
-            let __v_136: G = __r_arr[30];
-            let __v_137: G = __r_arr[31];
-            let __v_138: G = G::from_u64(1);
-            let __v_139: G = (__v_36 - __v_138);
-            let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_32, __v_33, __v_70, __v_73, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_140: G = __r_arr[0];
-            let __v_141: G = __r_arr[1];
-            let __v_142: G = __r_arr[2];
-            let __v_143: G = __r_arr[3];
-            let __v_144: G = __r_arr[4];
-            let __v_145: G = __r_arr[5];
-            let __v_146: G = __r_arr[6];
-            let __v_147: G = __r_arr[7];
-            let __v_148: G = __r_arr[8];
-            let __v_149: G = __r_arr[9];
-            let __v_150: G = __r_arr[10];
-            let __v_151: G = __r_arr[11];
-            let __v_152: G = __r_arr[12];
-            let __v_153: G = __r_arr[13];
-            let __v_154: G = __r_arr[14];
-            let __v_155: G = __r_arr[15];
-            let __v_156: G = __r_arr[16];
-            let __v_157: G = __r_arr[17];
-            let __v_158: G = __r_arr[18];
-            let __v_159: G = __r_arr[19];
-            let __v_160: G = __r_arr[20];
-            let __v_161: G = __r_arr[21];
-            let __v_162: G = __r_arr[22];
-            let __v_163: G = __r_arr[23];
-            let __v_164: G = __r_arr[24];
-            let __v_165: G = __r_arr[25];
-            let __v_166: G = __r_arr[26];
-            let __v_167: G = __r_arr[27];
-            let __v_168: G = __r_arr[28];
-            let __v_169: G = __r_arr[29];
-            let __v_170: G = __r_arr[30];
-            let __v_171: G = __r_arr[31];
-            let __v_172: G = __r_arr[32];
-            let __ret: [G; OUT_106] = [__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];
+            let __v_70: G = G::from_u64(0);
+            let __v_71: G = G::from_u64(1);
+            if (__v_70 != __v_71) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_106] = [__v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70];
             record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_71.as_canonical_u64()));
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_35.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_70: G = __loaded[0];
+            let __v_71: G = __loaded[1];
+            let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_70, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_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_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_72: G = __r_arr[0];
+            let __v_73: G = __r_arr[1];
+            let __v_74: G = __r_arr[2];
+            let __v_75: G = __r_arr[3];
+            let __v_76: G = __r_arr[4];
+            let __v_77: G = __r_arr[5];
+            let __v_78: G = __r_arr[6];
+            let __v_79: G = __r_arr[7];
+            let __v_80: G = __r_arr[8];
+            let __v_81: G = __r_arr[9];
+            let __v_82: G = __r_arr[10];
+            let __v_83: G = __r_arr[11];
+            let __v_84: G = __r_arr[12];
+            let __v_85: G = __r_arr[13];
+            let __v_86: G = __r_arr[14];
+            let __v_87: G = __r_arr[15];
+            let __v_88: G = __r_arr[16];
+            let __v_89: G = __r_arr[17];
+            let __v_90: G = __r_arr[18];
+            let __v_91: G = __r_arr[19];
+            let __v_92: G = __r_arr[20];
+            let __v_93: G = __r_arr[21];
+            let __v_94: G = __r_arr[22];
+            let __v_95: G = __r_arr[23];
+            let __v_96: G = __r_arr[24];
+            let __v_97: G = __r_arr[25];
+            let __v_98: G = __r_arr[26];
+            let __v_99: G = __r_arr[27];
+            let __v_100: G = __r_arr[28];
+            let __v_101: G = __r_arr[29];
+            let __v_102: G = __r_arr[30];
+            let __v_103: G = __r_arr[31];
+            let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_32, __v_33, __v_36, __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]; 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_104: G = __r_arr[0];
+            let __v_105: G = __r_arr[1];
+            let __v_106: G = __r_arr[2];
+            let __v_107: G = __r_arr[3];
+            let __v_108: G = __r_arr[4];
+            let __v_109: G = __r_arr[5];
+            let __v_110: G = __r_arr[6];
+            let __v_111: G = __r_arr[7];
+            let __v_112: G = __r_arr[8];
+            let __v_113: G = __r_arr[9];
+            let __v_114: G = __r_arr[10];
+            let __v_115: G = __r_arr[11];
+            let __v_116: G = __r_arr[12];
+            let __v_117: G = __r_arr[13];
+            let __v_118: G = __r_arr[14];
+            let __v_119: G = __r_arr[15];
+            let __v_120: G = __r_arr[16];
+            let __v_121: G = __r_arr[17];
+            let __v_122: G = __r_arr[18];
+            let __v_123: G = __r_arr[19];
+            let __v_124: G = __r_arr[20];
+            let __v_125: G = __r_arr[21];
+            let __v_126: G = __r_arr[22];
+            let __v_127: G = __r_arr[23];
+            let __v_128: G = __r_arr[24];
+            let __v_129: G = __r_arr[25];
+            let __v_130: G = __r_arr[26];
+            let __v_131: G = __r_arr[27];
+            let __v_132: G = __r_arr[28];
+            let __v_133: G = __r_arr[29];
+            let __v_134: G = __r_arr[30];
+            let __v_135: G = __r_arr[31];
+            let __v_136: G = G::from_u64(1);
+            let __v_137: G = (__v_36 - __v_136);
+            let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__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, __v_32, __v_33, __v_69, __v_71, __v_137]; 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_138: G = __r_arr[0];
+            let __v_139: G = __r_arr[1];
+            let __v_140: G = __r_arr[2];
+            let __v_141: G = __r_arr[3];
+            let __v_142: G = __r_arr[4];
+            let __v_143: G = __r_arr[5];
+            let __v_144: G = __r_arr[6];
+            let __v_145: G = __r_arr[7];
+            let __v_146: G = __r_arr[8];
+            let __v_147: G = __r_arr[9];
+            let __v_148: G = __r_arr[10];
+            let __v_149: G = __r_arr[11];
+            let __v_150: G = __r_arr[12];
+            let __v_151: G = __r_arr[13];
+            let __v_152: G = __r_arr[14];
+            let __v_153: G = __r_arr[15];
+            let __v_154: G = __r_arr[16];
+            let __v_155: G = __r_arr[17];
+            let __v_156: G = __r_arr[18];
+            let __v_157: G = __r_arr[19];
+            let __v_158: G = __r_arr[20];
+            let __v_159: G = __r_arr[21];
+            let __v_160: G = __r_arr[22];
+            let __v_161: G = __r_arr[23];
+            let __v_162: G = __r_arr[24];
+            let __v_163: G = __r_arr[25];
+            let __v_164: G = __r_arr[26];
+            let __v_165: G = __r_arr[27];
+            let __v_166: G = __r_arr[28];
+            let __v_167: G = __r_arr[29];
+            let __v_168: G = __r_arr[30];
+            let __v_169: G = __r_arr[31];
+            let __v_170: G = __r_arr[32];
+            let __ret: [G; OUT_106] = [__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];
+            record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64()));
-      },
     }
   })
 }
@@ -11366,28 +11367,23 @@ fn aiur_fn_109(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_109] = [__v_1];
         record.function_queries[109].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_109] = { let __args: [G; IN_109] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_109] = [__v_7];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = { let __values: [G; 2] = [__v_2, __v_1]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_3, __v_4]; 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_5: G = __r_arr[0];
+        let __ret: [G; OUT_109] = [__v_5];
         record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -11404,38 +11400,34 @@ fn aiur_fn_110(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_110] = [__v_5];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_110] = [__v_2];
         record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_5: G = (__v_0 * __v_0);
-        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_5, __v_4]; 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_6: G = __r_arr[0];
-        match __v_3.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = (__v_0 * __v_0);
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        match __v_2.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_110] = [__v_6];
+            let __ret: [G; OUT_110] = [__v_5];
             record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_7: G = (__v_0 * __v_6);
-            let __ret: [G; OUT_110] = [__v_7];
+            let __v_6: G = (__v_0 * __v_5);
+            let __ret: [G; OUT_110] = [__v_6];
             record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -11462,94 +11454,92 @@ fn aiur_fn_111(
     let __v_9: G = (__v_1 + __v_8);
     let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_9]; 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_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_109] = { let __args: [G; IN_109] = [__v_0, __v_13]; 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_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __v_16: G = (__v_15 + __v_15);
-    let __v_17: G = (__v_4 + __v_6);
-    let __v_18: G = (__v_5 + __v_7);
-    let __v_19: G = G::from_u64(2);
-    let __v_20: G = G::from_u64(0);
-    let __v_21: G = (__v_19 * __v_19);
-    let __v_22: G = G::from_u64(7);
-    let __v_23: G = (__v_20 * __v_20);
-    let __v_24: G = (__v_22 * __v_23);
-    let __v_25: G = (__v_21 - __v_24);
-    let __v_26: G = g_inverse_value(__v_25);
-    let __v_27: G = (__v_25 * __v_26);
-    let __v_28: G = G::from_u64(1);
-    let __v_29: G = (__v_27 - __v_28);
-    let __v_30: G = (__v_25 * __v_29);
+    let __v_11: G = G::from_u64(0);
+    let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0, __v_11]; 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_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_10, __v_12]; 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_13: G = __r_arr[0];
+    let __v_14: G = (__v_13 + __v_13);
+    let __v_15: G = (__v_4 + __v_6);
+    let __v_16: G = (__v_5 + __v_7);
+    let __v_17: G = G::from_u64(2);
+    let __v_18: G = G::from_u64(0);
+    let __v_19: G = (__v_17 * __v_17);
+    let __v_20: G = G::from_u64(7);
+    let __v_21: G = (__v_18 * __v_18);
+    let __v_22: G = (__v_20 * __v_21);
+    let __v_23: G = (__v_19 - __v_22);
+    let __v_24: G = g_inverse_value(__v_23);
+    let __v_25: G = (__v_23 * __v_24);
+    let __v_26: G = G::from_u64(1);
+    let __v_27: G = (__v_25 - __v_26);
+    let __v_28: G = (__v_23 * __v_27);
+    let __v_29: G = G::from_u64(0);
+    if (__v_28 != __v_29) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
+    }
+    let __v_30: G = (__v_24 * __v_27);
     let __v_31: G = G::from_u64(0);
     if (__v_30 != __v_31) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
     }
-    let __v_32: G = (__v_26 * __v_29);
+    let __v_32: G = (__v_17 * __v_24);
     let __v_33: G = G::from_u64(0);
-    if (__v_32 != __v_33) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None });
+    let __v_34: G = (__v_33 - __v_18);
+    let __v_35: G = (__v_34 * __v_24);
+    let __v_36: G = (__v_15 * __v_32);
+    let __v_37: G = G::from_u64(7);
+    let __v_38: G = (__v_16 * __v_35);
+    let __v_39: G = (__v_37 * __v_38);
+    let __v_40: G = (__v_36 + __v_39);
+    let __v_41: G = (__v_15 * __v_35);
+    let __v_42: G = (__v_16 * __v_32);
+    let __v_43: G = (__v_41 + __v_42);
+    let __v_44: G = (__v_4 - __v_6);
+    let __v_45: G = (__v_5 - __v_7);
+    let __v_46: G = G::from_u64(0);
+    let __v_47: G = (__v_14 * __v_14);
+    let __v_48: G = G::from_u64(7);
+    let __v_49: G = (__v_46 * __v_46);
+    let __v_50: G = (__v_48 * __v_49);
+    let __v_51: G = (__v_47 - __v_50);
+    let __v_52: G = g_inverse_value(__v_51);
+    let __v_53: G = (__v_51 * __v_52);
+    let __v_54: G = G::from_u64(1);
+    let __v_55: G = (__v_53 - __v_54);
+    let __v_56: G = (__v_51 * __v_55);
+    let __v_57: G = G::from_u64(0);
+    if (__v_56 != __v_57) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: None });
     }
-    let __v_34: G = (__v_19 * __v_26);
-    let __v_35: G = G::from_u64(0);
-    let __v_36: G = (__v_35 - __v_20);
-    let __v_37: G = (__v_36 * __v_26);
-    let __v_38: G = (__v_17 * __v_34);
-    let __v_39: G = G::from_u64(7);
-    let __v_40: G = (__v_18 * __v_37);
-    let __v_41: G = (__v_39 * __v_40);
-    let __v_42: G = (__v_38 + __v_41);
-    let __v_43: G = (__v_17 * __v_37);
-    let __v_44: G = (__v_18 * __v_34);
-    let __v_45: G = (__v_43 + __v_44);
-    let __v_46: G = (__v_4 - __v_6);
-    let __v_47: G = (__v_5 - __v_7);
-    let __v_48: G = G::from_u64(0);
-    let __v_49: G = (__v_16 * __v_16);
-    let __v_50: G = G::from_u64(7);
-    let __v_51: G = (__v_48 * __v_48);
-    let __v_52: G = (__v_50 * __v_51);
-    let __v_53: G = (__v_49 - __v_52);
-    let __v_54: G = g_inverse_value(__v_53);
-    let __v_55: G = (__v_53 * __v_54);
-    let __v_56: G = G::from_u64(1);
-    let __v_57: G = (__v_55 - __v_56);
-    let __v_58: G = (__v_53 * __v_57);
+    let __v_58: G = (__v_52 * __v_55);
     let __v_59: G = G::from_u64(0);
     if (__v_58 != __v_59) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None });
     }
-    let __v_60: G = (__v_54 * __v_57);
+    let __v_60: G = (__v_14 * __v_52);
     let __v_61: G = G::from_u64(0);
-    if (__v_60 != __v_61) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None });
-    }
-    let __v_62: G = (__v_16 * __v_54);
-    let __v_63: G = G::from_u64(0);
-    let __v_64: G = (__v_63 - __v_48);
-    let __v_65: G = (__v_64 * __v_54);
-    let __v_66: G = (__v_46 * __v_62);
-    let __v_67: G = G::from_u64(7);
-    let __v_68: G = (__v_47 * __v_65);
-    let __v_69: G = (__v_67 * __v_68);
-    let __v_70: G = (__v_66 + __v_69);
-    let __v_71: G = (__v_46 * __v_65);
-    let __v_72: G = (__v_47 * __v_62);
-    let __v_73: G = (__v_71 + __v_72);
-    let __v_74: G = (__v_2 * __v_70);
-    let __v_75: G = G::from_u64(7);
-    let __v_76: G = (__v_3 * __v_73);
-    let __v_77: G = (__v_75 * __v_76);
-    let __v_78: G = (__v_74 + __v_77);
-    let __v_79: G = (__v_2 * __v_73);
-    let __v_80: G = (__v_3 * __v_70);
-    let __v_81: G = (__v_79 + __v_80);
-    let __v_82: G = (__v_42 + __v_78);
-    let __v_83: G = (__v_45 + __v_81);
-    let __ret: [G; OUT_111] = [__v_82, __v_83];
+    let __v_62: G = (__v_61 - __v_46);
+    let __v_63: G = (__v_62 * __v_52);
+    let __v_64: G = (__v_44 * __v_60);
+    let __v_65: G = G::from_u64(7);
+    let __v_66: G = (__v_45 * __v_63);
+    let __v_67: G = (__v_65 * __v_66);
+    let __v_68: G = (__v_64 + __v_67);
+    let __v_69: G = (__v_44 * __v_63);
+    let __v_70: G = (__v_45 * __v_60);
+    let __v_71: G = (__v_69 + __v_70);
+    let __v_72: G = (__v_2 * __v_68);
+    let __v_73: G = G::from_u64(7);
+    let __v_74: G = (__v_3 * __v_71);
+    let __v_75: G = (__v_73 * __v_74);
+    let __v_76: G = (__v_72 + __v_75);
+    let __v_77: G = (__v_2 * __v_71);
+    let __v_78: G = (__v_3 * __v_68);
+    let __v_79: G = (__v_77 + __v_78);
+    let __v_80: G = (__v_40 + __v_76);
+    let __v_81: G = (__v_43 + __v_79);
+    let __ret: [G; OUT_111] = [__v_80, __v_81];
     record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -11570,15 +11560,13 @@ fn aiur_fn_112(
     let __v_2: G = G::from_u64(7);
     let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __v_4: G = G::from_u64(1);
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_3, __v_7]; 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_8: G = __r_arr[0];
-    let __v_9: G = (__v_2 * __v_8);
-    let __ret: [G; OUT_112] = [__v_9];
+    let __v_4: G = G::from_u64(0);
+    let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0, __v_4]; 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_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __v_7: G = (__v_2 * __v_6);
+    let __ret: [G; OUT_112] = [__v_7];
     record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -11595,59 +11583,52 @@ fn aiur_fn_113(
 ) -> Result<[G; OUT_113], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_113] = [__v_13];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_113] = [__v_1];
         record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(256);
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __v_10: G = G::from_u64(256);
+        let __v_11: G = (__v_10 * __v_2);
+        let __v_12: G = G::from_u64(65536);
         let __v_13: G = (__v_12 * __v_3);
-        let __v_14: G = G::from_u64(65536);
+        let __v_14: G = G::from_u64(16777216);
         let __v_15: G = (__v_14 * __v_4);
-        let __v_16: G = G::from_u64(16777216);
+        let __v_16: G = G::from_u64(4294967296);
         let __v_17: G = (__v_16 * __v_5);
-        let __v_18: G = G::from_u64(4294967296);
+        let __v_18: G = G::from_u64(1099511627776);
         let __v_19: G = (__v_18 * __v_6);
-        let __v_20: G = G::from_u64(1099511627776);
+        let __v_20: G = G::from_u64(281474976710656);
         let __v_21: G = (__v_20 * __v_7);
-        let __v_22: G = G::from_u64(281474976710656);
+        let __v_22: G = G::from_u64(72057594037927936);
         let __v_23: G = (__v_22 * __v_8);
-        let __v_24: G = G::from_u64(72057594037927936);
-        let __v_25: G = (__v_24 * __v_9);
-        let __v_26: G = (__v_23 + __v_25);
-        let __v_27: G = (__v_21 + __v_26);
-        let __v_28: G = (__v_19 + __v_27);
-        let __v_29: G = (__v_17 + __v_28);
-        let __v_30: G = (__v_15 + __v_29);
-        let __v_31: G = (__v_13 + __v_30);
-        let __v_32: G = (__v_2 + __v_31);
-        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
-        let __v_33: G = __r_arr[0];
-        let __v_34: G = { let __values: [G; 3] = [__v_11, __v_32, __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_113] = [__v_34];
+        let __v_24: G = (__v_21 + __v_23);
+        let __v_25: G = (__v_19 + __v_24);
+        let __v_26: G = (__v_17 + __v_25);
+        let __v_27: G = (__v_15 + __v_26);
+        let __v_28: G = (__v_13 + __v_27);
+        let __v_29: G = (__v_11 + __v_28);
+        let __v_30: G = (__v_1 + __v_29);
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+        let __v_31: G = __r_arr[0];
+        let __v_32: G = { let __values: [G; 2] = [__v_30, __v_31]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_113] = [__v_32];
         record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -11672,70 +11653,72 @@ fn aiur_fn_114(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_10: G = __loaded[0];
-    let __v_11: G = __loaded[1];
-    let __v_12: G = __loaded[2];
-    match __v_10.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_114] = [__v_6, __v_7, __v_8, __v_9];
         record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        let __v_16: G = __loaded[3];
-        match __v_13.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_10: G = __loaded[0];
+        let __v_11: G = __loaded[1];
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            let __v_17: G = G::from_u64(0);
-            let __v_18: G = (__v_14 - __v_11);
-            let __v_19: G = (__v_15 - __v_17);
-            let __v_20: G = (__v_8 * __v_18);
-            let __v_21: G = G::from_u64(7);
-            let __v_22: G = (__v_9 * __v_19);
-            let __v_23: G = (__v_21 * __v_22);
-            let __v_24: G = (__v_20 + __v_23);
-            let __v_25: G = (__v_8 * __v_19);
-            let __v_26: G = (__v_9 * __v_18);
-            let __v_27: G = (__v_25 + __v_26);
-            let __v_28: G = (__v_24 * __v_2);
-            let __v_29: G = G::from_u64(7);
-            let __v_30: G = (__v_27 * __v_3);
-            let __v_31: G = (__v_29 * __v_30);
-            let __v_32: G = (__v_28 + __v_31);
-            let __v_33: G = (__v_24 * __v_3);
-            let __v_34: G = (__v_27 * __v_2);
-            let __v_35: G = (__v_33 + __v_34);
-            let __v_36: G = (__v_6 + __v_32);
-            let __v_37: G = (__v_7 + __v_35);
-            let __v_38: G = (__v_8 * __v_4);
-            let __v_39: G = G::from_u64(7);
-            let __v_40: G = (__v_9 * __v_5);
-            let __v_41: G = (__v_39 * __v_40);
-            let __v_42: G = (__v_38 + __v_41);
-            let __v_43: G = (__v_8 * __v_5);
-            let __v_44: G = (__v_9 * __v_4);
-            let __v_45: G = (__v_43 + __v_44);
-            let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_12, __v_16, __v_2, __v_3, __v_4, __v_5, __v_36, __v_37, __v_42, __v_45]; 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_46: G = __r_arr[0];
-            let __v_47: G = __r_arr[1];
-            let __v_48: G = __r_arr[2];
-            let __v_49: G = __r_arr[3];
-            let __ret: [G; OUT_114] = [__v_46, __v_47, __v_48, __v_49];
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = G::from_u64(1);
+            if (__v_12 != __v_13) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_114] = [__v_12, __v_12, __v_12, __v_12];
             record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_12: G = __loaded[0];
+            let __v_13: G = __loaded[1];
+            let __v_14: G = __loaded[2];
+            let __v_15: G = G::from_u64(0);
+            let __v_16: G = (__v_12 - __v_10);
+            let __v_17: G = (__v_13 - __v_15);
+            let __v_18: G = (__v_8 * __v_16);
+            let __v_19: G = G::from_u64(7);
+            let __v_20: G = (__v_9 * __v_17);
+            let __v_21: G = (__v_19 * __v_20);
+            let __v_22: G = (__v_18 + __v_21);
+            let __v_23: G = (__v_8 * __v_17);
+            let __v_24: G = (__v_9 * __v_16);
+            let __v_25: G = (__v_23 + __v_24);
+            let __v_26: G = (__v_22 * __v_2);
+            let __v_27: G = G::from_u64(7);
+            let __v_28: G = (__v_25 * __v_3);
+            let __v_29: G = (__v_27 * __v_28);
+            let __v_30: G = (__v_26 + __v_29);
+            let __v_31: G = (__v_22 * __v_3);
+            let __v_32: G = (__v_25 * __v_2);
+            let __v_33: G = (__v_31 + __v_32);
+            let __v_34: G = (__v_6 + __v_30);
+            let __v_35: G = (__v_7 + __v_33);
+            let __v_36: G = (__v_8 * __v_4);
+            let __v_37: G = G::from_u64(7);
+            let __v_38: G = (__v_9 * __v_5);
+            let __v_39: G = (__v_37 * __v_38);
+            let __v_40: G = (__v_36 + __v_39);
+            let __v_41: G = (__v_8 * __v_5);
+            let __v_42: G = (__v_9 * __v_4);
+            let __v_43: G = (__v_41 + __v_42);
+            let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_11, __v_14, __v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_40, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+            let __v_44: G = __r_arr[0];
+            let __v_45: G = __r_arr[1];
+            let __v_46: G = __r_arr[2];
+            let __v_47: G = __r_arr[3];
+            let __ret: [G; OUT_114] = [__v_44, __v_45, __v_46, __v_47];
+            record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-      },
     }
   })
 }
@@ -11752,143 +11735,139 @@ fn aiur_fn_115(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_115] = [__v_1];
         record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
+      _ => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes();
+        let __v_5: G = G::from_u8(__gb[0]);
+        let __v_6: G = G::from_u8(__gb[1]);
+        let __v_7: G = G::from_u8(__gb[2]);
+        let __v_8: G = G::from_u8(__gb[3]);
+        let __v_9: G = G::from_u8(__gb[4]);
+        let __v_10: G = G::from_u8(__gb[5]);
+        let __v_11: G = G::from_u8(__gb[6]);
+        let __v_12: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_9; let __vj = __v_10; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_11; let __vj = __v_12; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_13: G = G::from_u64(1020);
+        let __v_14: G = (__v_12 - __v_13);
+        let __v_15: G = (__v_11 + __v_14);
+        let __v_16: G = (__v_10 + __v_15);
+        let __v_17: G = (__v_9 + __v_16);
+        let __v_18: G = G::from_bool((__v_17 == G::ZERO));
+        let __v_19: G = (__v_7 + __v_8);
+        let __v_20: G = (__v_6 + __v_19);
+        let __v_21: G = (__v_5 + __v_20);
+        let __v_22: G = G::from_bool((__v_21 == G::ZERO));
         let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes();
-        let __v_6: G = G::from_u8(__gb[0]);
-        let __v_7: G = G::from_u8(__gb[1]);
-        let __v_8: G = G::from_u8(__gb[2]);
-        let __v_9: G = G::from_u8(__gb[3]);
-        let __v_10: G = G::from_u8(__gb[4]);
-        let __v_11: G = G::from_u8(__gb[5]);
-        let __v_12: G = G::from_u8(__gb[6]);
-        let __v_13: G = G::from_u8(__gb[7]);
-        if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_14: G = G::from_u64(1020);
-        let __v_15: G = (__v_13 - __v_14);
-        let __v_16: G = (__v_12 + __v_15);
-        let __v_17: G = (__v_11 + __v_16);
-        let __v_18: G = (__v_10 + __v_17);
-        let __v_19: G = G::from_bool((__v_18 == G::ZERO));
-        let __v_20: G = (__v_8 + __v_9);
-        let __v_21: G = (__v_7 + __v_20);
-        let __v_22: G = (__v_6 + __v_21);
-        let __v_23: G = G::from_bool((__v_22 == G::ZERO));
-        let __gb: [u8; 8] = __v_4.as_canonical_u64().to_le_bytes();
-        let __v_24: G = G::from_u8(__gb[0]);
-        let __v_25: G = G::from_u8(__gb[1]);
-        let __v_26: G = G::from_u8(__gb[2]);
-        let __v_27: G = G::from_u8(__gb[3]);
-        let __v_28: G = G::from_u8(__gb[4]);
-        let __v_29: G = G::from_u8(__gb[5]);
-        let __v_30: G = G::from_u8(__gb[6]);
-        let __v_31: G = G::from_u8(__gb[7]);
-        if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_30; let __vj = __v_31; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_32: G = G::from_u64(1020);
-        let __v_33: G = (__v_31 - __v_32);
-        let __v_34: G = (__v_30 + __v_33);
-        let __v_35: G = (__v_29 + __v_34);
-        let __v_36: G = (__v_28 + __v_35);
-        let __v_37: G = G::from_bool((__v_36 == G::ZERO));
-        let __v_38: G = (__v_26 + __v_27);
-        let __v_39: G = (__v_25 + __v_38);
-        let __v_40: G = (__v_24 + __v_39);
-        let __v_41: G = G::from_bool((__v_40 == G::ZERO));
-        let __v_42: G = G::from_u64(256);
-        let __v_43: G = (__v_42 * __v_7);
-        let __v_44: G = G::from_u64(65536);
-        let __v_45: G = (__v_44 * __v_8);
-        let __v_46: G = G::from_u64(16777216);
-        let __v_47: G = (__v_46 * __v_9);
-        let __v_48: G = G::from_u64(4294967296);
-        let __v_49: G = (__v_48 * __v_10);
-        let __v_50: G = G::from_u64(1099511627776);
-        let __v_51: G = (__v_50 * __v_11);
-        let __v_52: G = G::from_u64(281474976710656);
-        let __v_53: G = (__v_52 * __v_12);
-        let __v_54: G = G::from_u64(72057594037927936);
-        let __v_55: G = (__v_54 * __v_13);
-        let __v_56: G = (__v_53 + __v_55);
-        let __v_57: G = (__v_51 + __v_56);
-        let __v_58: G = (__v_49 + __v_57);
-        let __v_59: G = (__v_47 + __v_58);
-        let __v_60: G = (__v_45 + __v_59);
-        let __v_61: G = (__v_43 + __v_60);
-        let __v_62: G = (__v_6 + __v_61);
-        if (__v_62 != __v_3) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
+        let __v_23: G = G::from_u8(__gb[0]);
+        let __v_24: G = G::from_u8(__gb[1]);
+        let __v_25: G = G::from_u8(__gb[2]);
+        let __v_26: G = G::from_u8(__gb[3]);
+        let __v_27: G = G::from_u8(__gb[4]);
+        let __v_28: G = G::from_u8(__gb[5]);
+        let __v_29: G = G::from_u8(__gb[6]);
+        let __v_30: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_23; let __vj = __v_24; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_25; let __vj = __v_26; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_27; let __vj = __v_28; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_29; let __vj = __v_30; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_31: G = G::from_u64(1020);
+        let __v_32: G = (__v_30 - __v_31);
+        let __v_33: G = (__v_29 + __v_32);
+        let __v_34: G = (__v_28 + __v_33);
+        let __v_35: G = (__v_27 + __v_34);
+        let __v_36: G = G::from_bool((__v_35 == G::ZERO));
+        let __v_37: G = (__v_25 + __v_26);
+        let __v_38: G = (__v_24 + __v_37);
+        let __v_39: G = (__v_23 + __v_38);
+        let __v_40: G = G::from_bool((__v_39 == G::ZERO));
+        let __v_41: G = G::from_u64(256);
+        let __v_42: G = (__v_41 * __v_6);
+        let __v_43: G = G::from_u64(65536);
+        let __v_44: G = (__v_43 * __v_7);
+        let __v_45: G = G::from_u64(16777216);
+        let __v_46: G = (__v_45 * __v_8);
+        let __v_47: G = G::from_u64(4294967296);
+        let __v_48: G = (__v_47 * __v_9);
+        let __v_49: G = G::from_u64(1099511627776);
+        let __v_50: G = (__v_49 * __v_10);
+        let __v_51: G = G::from_u64(281474976710656);
+        let __v_52: G = (__v_51 * __v_11);
+        let __v_53: G = G::from_u64(72057594037927936);
+        let __v_54: G = (__v_53 * __v_12);
+        let __v_55: G = (__v_52 + __v_54);
+        let __v_56: G = (__v_50 + __v_55);
+        let __v_57: G = (__v_48 + __v_56);
+        let __v_58: G = (__v_46 + __v_57);
+        let __v_59: G = (__v_44 + __v_58);
+        let __v_60: G = (__v_42 + __v_59);
+        let __v_61: G = (__v_5 + __v_60);
+        if (__v_61 != __v_2) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None });
         }
+        let __v_62: G = G::from_u64(1);
         let __v_63: G = G::from_u64(1);
-        let __v_64: G = G::from_u64(1);
-        let __v_65: G = (__v_64 - __v_23);
-        let __v_66: G = (__v_19 * __v_65);
-        let __v_67: G = (__v_63 - __v_66);
-        let __v_68: G = G::from_u64(1);
-        if (__v_67 != __v_68) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_68.as_canonical_u64(), msg: None });
+        let __v_64: G = (__v_63 - __v_22);
+        let __v_65: G = (__v_18 * __v_64);
+        let __v_66: G = (__v_62 - __v_65);
+        let __v_67: G = G::from_u64(1);
+        if (__v_66 != __v_67) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None });
         }
-        let __v_69: G = G::from_u64(256);
-        let __v_70: G = (__v_69 * __v_25);
-        let __v_71: G = G::from_u64(65536);
-        let __v_72: G = (__v_71 * __v_26);
-        let __v_73: G = G::from_u64(16777216);
-        let __v_74: G = (__v_73 * __v_27);
-        let __v_75: G = G::from_u64(4294967296);
-        let __v_76: G = (__v_75 * __v_28);
-        let __v_77: G = G::from_u64(1099511627776);
-        let __v_78: G = (__v_77 * __v_29);
-        let __v_79: G = G::from_u64(281474976710656);
-        let __v_80: G = (__v_79 * __v_30);
-        let __v_81: G = G::from_u64(72057594037927936);
-        let __v_82: G = (__v_81 * __v_31);
-        let __v_83: G = (__v_80 + __v_82);
-        let __v_84: G = (__v_78 + __v_83);
-        let __v_85: G = (__v_76 + __v_84);
-        let __v_86: G = (__v_74 + __v_85);
-        let __v_87: G = (__v_72 + __v_86);
-        let __v_88: G = (__v_70 + __v_87);
-        let __v_89: G = (__v_24 + __v_88);
-        if (__v_89 != __v_4) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None });
+        let __v_68: G = G::from_u64(256);
+        let __v_69: G = (__v_68 * __v_24);
+        let __v_70: G = G::from_u64(65536);
+        let __v_71: G = (__v_70 * __v_25);
+        let __v_72: G = G::from_u64(16777216);
+        let __v_73: G = (__v_72 * __v_26);
+        let __v_74: G = G::from_u64(4294967296);
+        let __v_75: G = (__v_74 * __v_27);
+        let __v_76: G = G::from_u64(1099511627776);
+        let __v_77: G = (__v_76 * __v_28);
+        let __v_78: G = G::from_u64(281474976710656);
+        let __v_79: G = (__v_78 * __v_29);
+        let __v_80: G = G::from_u64(72057594037927936);
+        let __v_81: G = (__v_80 * __v_30);
+        let __v_82: G = (__v_79 + __v_81);
+        let __v_83: G = (__v_77 + __v_82);
+        let __v_84: G = (__v_75 + __v_83);
+        let __v_85: G = (__v_73 + __v_84);
+        let __v_86: G = (__v_71 + __v_85);
+        let __v_87: G = (__v_69 + __v_86);
+        let __v_88: G = (__v_23 + __v_87);
+        if (__v_88 != __v_3) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
         }
+        let __v_89: G = G::from_u64(1);
         let __v_90: G = G::from_u64(1);
-        let __v_91: G = G::from_u64(1);
-        let __v_92: G = (__v_91 - __v_41);
-        let __v_93: G = (__v_37 * __v_92);
-        let __v_94: G = (__v_90 - __v_93);
-        let __v_95: G = G::from_u64(1);
-        if (__v_94 != __v_95) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_95.as_canonical_u64(), msg: None });
+        let __v_91: G = (__v_90 - __v_40);
+        let __v_92: G = (__v_36 * __v_91);
+        let __v_93: G = (__v_89 - __v_92);
+        let __v_94: G = G::from_u64(1);
+        if (__v_93 != __v_94) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_94.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __v_95: G = __r_arr[0];
+        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_95]; 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_96: G = __r_arr[0];
-        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_145] = { let __args: [G; IN_145] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_96]; 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_97: G = __r_arr[0];
-        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_98: G = __r_arr[0];
-        let __ret: [G; OUT_115] = [__v_98];
+        let __ret: [G; OUT_115] = [__v_97];
         record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -11905,28 +11884,24 @@ fn aiur_fn_116(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_116] = [__v_1];
         record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_4, __v_1]; 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 __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_3, __v_1]; 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_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_116] = [__v_6];
+        let __ret: [G; OUT_116] = [__v_5];
         record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -11943,28 +11918,24 @@ fn aiur_fn_117(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_117] = [__v_1];
         record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !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 __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } else { aiur_fn_117(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_2, __v_4]; 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_117] = [__v_6];
+        let __ret: [G; OUT_117] = [__v_5];
         record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -12014,36 +11985,32 @@ fn aiur_fn_119(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_1.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_119] = [__v_0];
         record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_5: G = G::from_u64(1);
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_156] = { let __args: [G; IN_156] = [__v_0, __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[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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_12, __v_3]; 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_13, __v_4]; 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_14: G = __r_arr[0];
-        let __ret: [G; OUT_119] = [__v_14];
+        let __ret: [G; OUT_119] = [__v_13];
         record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -12070,30 +12037,26 @@ fn aiur_fn_120(
     let __v_9: G = inp[9];
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_120] = [__v_0, __v_12];
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_120] = [__v_0, __v_10];
         record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__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[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_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_155] = { let __args: [G; IN_155] = [__v_10, __v_13, __v_9]; 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_14: G = __r_arr[0];
-        let __v_15: G = __r_arr[1];
-        let __v_16: G = __r_arr[2];
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __v_18: G = G::from_u64(0);
-        if (__v_17 != __v_18) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
+        let __v_11: G = G::from_u64(0);
+        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_10, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __v_13: G = __r_arr[1];
+        let __v_14: G = __r_arr[2];
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = __r_arr[0];
+        let __v_16: G = G::from_u64(0);
+        if (__v_15 != __v_16) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None });
         }
-        let __ret: [G; OUT_120] = [__v_15, __v_16];
+        let __ret: [G; OUT_120] = [__v_13, __v_14];
         record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -12115,116 +12078,115 @@ fn aiur_fn_121(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_121] = [__v_9, __v_0];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_121] = [__v_4, __v_0];
         record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        let __v_10: G = __loaded[3];
-        let __v_11: G = __loaded[4];
-        let __v_12: G = __loaded[5];
-        let __v_13: G = __loaded[6];
-        let __v_14: G = __loaded[7];
-        let __v_15: G = __loaded[8];
-        let __v_16: G = __loaded[9];
-        match __v_7.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_0, __v_5]; 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 __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
-            let __v_18: G = __r_arr[0];
-            let __v_19: G = __r_arr[1];
-            let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-            let __v_20: G = __r_arr[0];
-            let __v_21: G = __r_arr[1];
-            let __v_22: G = __r_arr[2];
-            let __v_23: G = __r_arr[3];
-            let __v_24: G = __r_arr[4];
-            let __v_25: G = __r_arr[5];
-            let __v_26: G = __r_arr[6];
-            let __v_27: G = __r_arr[7];
-            let __v_28: G = __r_arr[8];
-            let __v_29: G = __r_arr[9];
-            let __v_30: G = __r_arr[10];
-            let __v_31: G = __r_arr[11];
-            let __v_32: G = __r_arr[12];
-            let __v_33: G = __r_arr[13];
-            let __v_34: G = __r_arr[14];
-            let __v_35: G = __r_arr[15];
-            let __v_36: G = __r_arr[16];
-            let __v_37: G = __r_arr[17];
-            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_36, __v_6, __v_16, __v_3]; 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_38: G = __r_arr[0];
-            let __v_39: G = __r_arr[1];
-            let __v_40: G = G::from_u64(0);
-            let __v_41: G = G::from_u64(256);
-            let __v_42: G = (__v_41 * __v_21);
-            let __v_43: G = G::from_u64(65536);
-            let __v_44: G = (__v_43 * __v_22);
-            let __v_45: G = G::from_u64(16777216);
-            let __v_46: G = (__v_45 * __v_23);
-            let __v_47: G = G::from_u64(4294967296);
-            let __v_48: G = (__v_47 * __v_24);
-            let __v_49: G = G::from_u64(1099511627776);
-            let __v_50: G = (__v_49 * __v_25);
-            let __v_51: G = G::from_u64(281474976710656);
-            let __v_52: G = (__v_51 * __v_26);
-            let __v_53: G = G::from_u64(72057594037927936);
-            let __v_54: G = (__v_53 * __v_27);
-            let __v_55: G = (__v_52 + __v_54);
-            let __v_56: G = (__v_50 + __v_55);
-            let __v_57: G = (__v_48 + __v_56);
-            let __v_58: G = (__v_46 + __v_57);
-            let __v_59: G = (__v_44 + __v_58);
-            let __v_60: G = (__v_42 + __v_59);
-            let __v_61: G = (__v_20 + __v_60);
-            let __v_62: G = G::from_u64(256);
-            let __v_63: G = (__v_62 * __v_29);
-            let __v_64: G = G::from_u64(65536);
-            let __v_65: G = (__v_64 * __v_30);
-            let __v_66: G = G::from_u64(16777216);
-            let __v_67: G = (__v_66 * __v_31);
-            let __v_68: G = G::from_u64(4294967296);
-            let __v_69: G = (__v_68 * __v_32);
-            let __v_70: G = G::from_u64(1099511627776);
-            let __v_71: G = (__v_70 * __v_33);
-            let __v_72: G = G::from_u64(281474976710656);
-            let __v_73: G = (__v_72 * __v_34);
-            let __v_74: G = G::from_u64(72057594037927936);
-            let __v_75: G = (__v_74 * __v_35);
-            let __v_76: G = (__v_73 + __v_75);
-            let __v_77: G = (__v_71 + __v_76);
-            let __v_78: G = (__v_69 + __v_77);
-            let __v_79: G = (__v_67 + __v_78);
-            let __v_80: G = (__v_65 + __v_79);
-            let __v_81: G = (__v_63 + __v_80);
-            let __v_82: G = (__v_28 + __v_81);
-            let __v_83: G = { let __values: [G; 4] = [__v_40, __v_61, __v_82, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_121] = [__v_83, __v_39];
+            let __v_6: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_121] = [__v_6, __v_6];
             record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+            let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+            let __v_6: G = __loaded[0];
+            let __v_7: G = __loaded[1];
+            let __v_8: G = __loaded[2];
+            let __v_9: G = __loaded[3];
+            let __v_10: G = __loaded[4];
+            let __v_11: G = __loaded[5];
+            let __v_12: G = __loaded[6];
+            let __v_13: G = __loaded[7];
+            let __v_14: G = __loaded[8];
+            let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_0, __v_4]; 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_15: G = __r_arr[0];
+            let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_15, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+            let __v_16: G = __r_arr[0];
+            let __v_17: G = __r_arr[1];
+            let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_16, __v_17]; 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_18: G = __r_arr[0];
+            let __v_19: G = __r_arr[1];
+            let __v_20: G = __r_arr[2];
+            let __v_21: G = __r_arr[3];
+            let __v_22: G = __r_arr[4];
+            let __v_23: G = __r_arr[5];
+            let __v_24: G = __r_arr[6];
+            let __v_25: G = __r_arr[7];
+            let __v_26: G = __r_arr[8];
+            let __v_27: G = __r_arr[9];
+            let __v_28: G = __r_arr[10];
+            let __v_29: G = __r_arr[11];
+            let __v_30: G = __r_arr[12];
+            let __v_31: G = __r_arr[13];
+            let __v_32: G = __r_arr[14];
+            let __v_33: G = __r_arr[15];
+            let __v_34: G = __r_arr[16];
+            let __v_35: G = __r_arr[17];
+            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_34, __v_5, __v_14, __v_3]; 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_36: G = __r_arr[0];
+            let __v_37: G = __r_arr[1];
+            let __v_38: G = G::from_u64(256);
+            let __v_39: G = (__v_38 * __v_19);
+            let __v_40: G = G::from_u64(65536);
+            let __v_41: G = (__v_40 * __v_20);
+            let __v_42: G = G::from_u64(16777216);
+            let __v_43: G = (__v_42 * __v_21);
+            let __v_44: G = G::from_u64(4294967296);
+            let __v_45: G = (__v_44 * __v_22);
+            let __v_46: G = G::from_u64(1099511627776);
+            let __v_47: G = (__v_46 * __v_23);
+            let __v_48: G = G::from_u64(281474976710656);
+            let __v_49: G = (__v_48 * __v_24);
+            let __v_50: G = G::from_u64(72057594037927936);
+            let __v_51: G = (__v_50 * __v_25);
+            let __v_52: G = (__v_49 + __v_51);
+            let __v_53: G = (__v_47 + __v_52);
+            let __v_54: G = (__v_45 + __v_53);
+            let __v_55: G = (__v_43 + __v_54);
+            let __v_56: G = (__v_41 + __v_55);
+            let __v_57: G = (__v_39 + __v_56);
+            let __v_58: G = (__v_18 + __v_57);
+            let __v_59: G = G::from_u64(256);
+            let __v_60: G = (__v_59 * __v_27);
+            let __v_61: G = G::from_u64(65536);
+            let __v_62: G = (__v_61 * __v_28);
+            let __v_63: G = G::from_u64(16777216);
+            let __v_64: G = (__v_63 * __v_29);
+            let __v_65: G = G::from_u64(4294967296);
+            let __v_66: G = (__v_65 * __v_30);
+            let __v_67: G = G::from_u64(1099511627776);
+            let __v_68: G = (__v_67 * __v_31);
+            let __v_69: G = G::from_u64(281474976710656);
+            let __v_70: G = (__v_69 * __v_32);
+            let __v_71: G = G::from_u64(72057594037927936);
+            let __v_72: G = (__v_71 * __v_33);
+            let __v_73: G = (__v_70 + __v_72);
+            let __v_74: G = (__v_68 + __v_73);
+            let __v_75: G = (__v_66 + __v_74);
+            let __v_76: G = (__v_64 + __v_75);
+            let __v_77: G = (__v_62 + __v_76);
+            let __v_78: G = (__v_60 + __v_77);
+            let __v_79: G = (__v_26 + __v_78);
+            let __v_80: G = { let __values: [G; 3] = [__v_58, __v_79, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_121] = [__v_80, __v_37];
+            record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
     }
   })
 }
@@ -12297,10 +12259,8 @@ fn aiur_fn_123(
     let __v_3: G = inp[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_123] = [__v_6];
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_123] = [__v_4];
         record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -12319,17 +12279,16 @@ fn aiur_fn_123(
             return Ok(__ret);
           },
           _ => {
-            let __v_6: G = G::from_u64(0);
-            let __v_7: G = G::from_u64(1);
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = G::from_u64(0);
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(0);
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = (__v_3 - __v_11);
-            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_12]; 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_13: G = __r_arr[0];
-            let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_123] = [__v_14];
+            let __v_10: G = G::from_u64(1);
+            let __v_11: G = (__v_3 - __v_10);
+            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_11]; 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_12: G = __r_arr[0];
+            let __v_13: G = { let __values: [G; 6] = [__v_3, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_123] = [__v_13];
             record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -12357,47 +12316,42 @@ fn aiur_fn_124(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
-    let __v_8: G = __loaded[0];
-    let __v_9: G = __loaded[1];
-    let __v_10: G = __loaded[2];
-    let __v_11: G = __loaded[3];
-    let __v_12: G = __loaded[4];
-    let __v_13: G = __loaded[5];
-    let __v_14: G = __loaded[6];
-    match __v_8.as_canonical_u64() {
-      1u64 => {
-        let __v_15: G = G::from_u64(1);
-        let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_124] = [__v_17];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_124] = [__v_8];
         record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_9.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_8: G = __loaded[0];
+        let __v_9: G = __loaded[1];
+        let __v_10: G = __loaded[2];
+        let __v_11: G = __loaded[3];
+        let __v_12: G = __loaded[4];
+        let __v_13: G = __loaded[5];
+        match __v_8.as_canonical_u64() {
           _ => {
-            let __v_15: G = (__v_9 - __v_1);
-            let __v_16: G = G::from_bool((__v_15 == G::ZERO));
-            match __v_16.as_canonical_u64() {
+            let __v_14: G = (__v_8 - __v_1);
+            let __v_15: G = G::from_bool((__v_14 == G::ZERO));
+            match __v_15.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_12, __v_13, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_17: G = __r_arr[0];
-                let __v_18: G = __r_arr[1];
-                let __v_19: G = __r_arr[2];
-                let __v_20: G = __r_arr[3];
-                let __v_21: G = G::from_u64(0);
-                let __v_22: G = { let __values: [G; 7] = [__v_21, __v_9, __v_19, __v_20, __v_17, __v_18, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_124] = [__v_22];
+                let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_12, __v_9, __v_10]; 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_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 = { let __values: [G; 6] = [__v_8, __v_18, __v_19, __v_16, __v_17, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_124] = [__v_20];
                 record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_17: G = G::from_u64(0);
-                let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_18: G = __r_arr[0];
-                let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_124] = [__v_19];
+                let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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_16: G = __r_arr[0];
+                let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_124] = [__v_17];
                 record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -12405,9 +12359,6 @@ fn aiur_fn_124(
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-      },
     }
   })
 }
@@ -12424,48 +12375,47 @@ fn aiur_fn_125(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_9: G = G::from_u64(1);
-        let __ret: [G; OUT_125] = [__v_9];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_125] = [__v_2];
         record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_3.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        match __v_2.as_canonical_u64() {
           _ => {
-            let __v_9: G = (__v_3 - __v_1);
-            let __v_10: G = G::from_bool((__v_9 == G::ZERO));
-            match __v_10.as_canonical_u64() {
+            let __v_8: G = (__v_2 - __v_1);
+            let __v_9: G = G::from_bool((__v_8 == G::ZERO));
+            match __v_9.as_canonical_u64() {
               1u64 => {
+                let __v_10: G = G::from_u64(0);
                 let __v_11: G = G::from_u64(0);
-                let __v_12: G = G::from_u64(0);
-                let __v_13: G = (__v_6 - __v_11);
-                let __v_14: G = G::from_bool((__v_13 == G::ZERO));
-                let __v_15: G = (__v_7 - __v_12);
-                let __v_16: G = G::from_bool((__v_15 == G::ZERO));
-                let __v_17: G = (__v_14 * __v_16);
-                let __v_18: G = G::from_u64(1);
-                if (__v_17 != __v_18) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
+                let __v_12: G = (__v_5 - __v_10);
+                let __v_13: G = G::from_bool((__v_12 == G::ZERO));
+                let __v_14: G = (__v_6 - __v_11);
+                let __v_15: G = G::from_bool((__v_14 == G::ZERO));
+                let __v_16: G = (__v_13 * __v_15);
+                let __v_17: G = G::from_u64(1);
+                if (__v_16 != __v_17) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None });
                 }
-                let __v_19: G = G::from_u64(1);
-                let __ret: [G; OUT_125] = [__v_19];
+                let __v_18: G = G::from_u64(1);
+                let __ret: [G; OUT_125] = [__v_18];
                 record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
-                let __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_125] = [__v_11];
+                let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+                let __v_10: G = __r_arr[0];
+                let __ret: [G; OUT_125] = [__v_10];
                 record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -12473,9 +12423,6 @@ fn aiur_fn_125(
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -12563,7 +12510,7 @@ fn aiur_fn_127(
     let __v_30: G = G::from_u64(0);
     let __v_31: G = (__v_30 - __v_15);
     let __v_32: G = (__v_31 * __v_21);
-    let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_6]; 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_33: G = __r_arr[0];
     let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !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_34: G = __r_arr[0];
@@ -12865,9 +12812,9 @@ fn aiur_fn_132(
             let __v_19: G = __r_arr[0];
             let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
-            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_16]; 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_203] = { let __args: [G; IN_203] = [__v_16]; 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_21: G = __r_arr[0];
-            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
             let __v_23: G = (__v_21 - __v_22);
             let __v_24: G = G::from_bool((__v_23 == G::ZERO));
@@ -12917,26 +12864,23 @@ fn aiur_fn_133(
     let __v_3: G = inp[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_133] = [__v_6];
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_133] = [__v_4];
         record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_4: G = G::from_u64(0);
         let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !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_5: G = __r_arr[0];
-        let __v_6: G = (__v_5 + __v_1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = (__v_2 - __v_7);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = (__v_3 + __v_9);
-        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_133] = [__v_12];
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = (__v_4 + __v_1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_2 - __v_6);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_3 + __v_8);
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __v_7, __v_9]; 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_10: G = __r_arr[0];
+        let __v_11: G = { let __values: [G; 2] = [__v_5, __v_10]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_133] = [__v_11];
         record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -12955,37 +12899,33 @@ fn aiur_fn_134(
 ) -> Result<[G; OUT_134], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_134] = [__v_4];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_134] = [__v_1];
         record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-        match __v_5.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __v_4: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+        match __v_4.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_134] = [__v_4];
+            let __ret: [G; OUT_134] = [__v_3];
             record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_134] = [__v_2];
+            let __ret: [G; OUT_134] = [__v_1];
             record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -13007,10 +12947,8 @@ fn aiur_fn_135(
     let __v_4: G = inp[4];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_135] = [__v_7];
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_135] = [__v_5];
         record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -13031,18 +12969,17 @@ fn aiur_fn_135(
             return Ok(__ret);
           },
           1u64 => {
-            let __v_7: G = G::from_u64(0);
             let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_4]; 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_8: G = __r_arr[0];
-            let __v_9: G = (__v_8 + __v_1);
-            let __v_10: G = G::from_u64(1);
-            let __v_11: G = (__v_3 - __v_10);
-            let __v_12: G = G::from_u64(1);
-            let __v_13: G = (__v_4 + __v_12);
-            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_1, __v_2, __v_11, __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_14: G = __r_arr[0];
-            let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_135] = [__v_15];
+            let __v_7: G = __r_arr[0];
+            let __v_8: G = (__v_7 + __v_1);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = (__v_3 - __v_9);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = (__v_4 + __v_11);
+            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_1, __v_2, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __v_14: G = { let __values: [G; 2] = [__v_8, __v_13]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_135] = [__v_14];
             record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -13191,150 +13128,144 @@ fn aiur_fn_137(
     let __v_73: G = (__v_59 + __v_72);
     let __v_74: G = (__v_58 + __v_73);
     let __v_75: G = G::from_bool((__v_74 == G::ZERO));
-    let __v_76: G = G::from_u64(0);
-    let __v_77: G = G::from_u64(256);
-    let __v_78: G = (__v_77 * __v_5);
-    let __v_79: G = G::from_u64(65536);
-    let __v_80: G = (__v_79 * __v_6);
-    let __v_81: G = G::from_u64(16777216);
-    let __v_82: G = (__v_81 * __v_7);
-    let __v_83: G = G::from_u64(4294967296);
-    let __v_84: G = (__v_83 * __v_8);
-    let __v_85: G = G::from_u64(1099511627776);
-    let __v_86: G = (__v_85 * __v_9);
-    let __v_87: G = G::from_u64(281474976710656);
-    let __v_88: G = (__v_87 * __v_10);
-    let __v_89: G = G::from_u64(72057594037927936);
-    let __v_90: G = (__v_89 * __v_11);
-    let __v_91: G = (__v_88 + __v_90);
-    let __v_92: G = (__v_86 + __v_91);
-    let __v_93: G = (__v_84 + __v_92);
-    let __v_94: G = (__v_82 + __v_93);
-    let __v_95: G = (__v_80 + __v_94);
-    let __v_96: G = (__v_78 + __v_95);
-    let __v_97: G = (__v_4 + __v_96);
-    if (__v_97 != __v_0) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
+    let __v_76: G = G::from_u64(256);
+    let __v_77: G = (__v_76 * __v_5);
+    let __v_78: G = G::from_u64(65536);
+    let __v_79: G = (__v_78 * __v_6);
+    let __v_80: G = G::from_u64(16777216);
+    let __v_81: G = (__v_80 * __v_7);
+    let __v_82: G = G::from_u64(4294967296);
+    let __v_83: G = (__v_82 * __v_8);
+    let __v_84: G = G::from_u64(1099511627776);
+    let __v_85: G = (__v_84 * __v_9);
+    let __v_86: G = G::from_u64(281474976710656);
+    let __v_87: G = (__v_86 * __v_10);
+    let __v_88: G = G::from_u64(72057594037927936);
+    let __v_89: G = (__v_88 * __v_11);
+    let __v_90: G = (__v_87 + __v_89);
+    let __v_91: G = (__v_85 + __v_90);
+    let __v_92: G = (__v_83 + __v_91);
+    let __v_93: G = (__v_81 + __v_92);
+    let __v_94: G = (__v_79 + __v_93);
+    let __v_95: G = (__v_77 + __v_94);
+    let __v_96: G = (__v_4 + __v_95);
+    if (__v_96 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
     }
+    let __v_97: G = G::from_u64(1);
     let __v_98: G = G::from_u64(1);
-    let __v_99: G = G::from_u64(1);
-    let __v_100: G = (__v_99 - __v_21);
-    let __v_101: G = (__v_17 * __v_100);
-    let __v_102: G = (__v_98 - __v_101);
-    let __v_103: G = G::from_u64(1);
-    if (__v_102 != __v_103) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None });
+    let __v_99: G = (__v_98 - __v_21);
+    let __v_100: G = (__v_17 * __v_99);
+    let __v_101: G = (__v_97 - __v_100);
+    let __v_102: G = G::from_u64(1);
+    if (__v_101 != __v_102) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_101.as_canonical_u64(), rhs: __v_102.as_canonical_u64(), msg: None });
     }
-    let __v_104: G = G::from_u64(0);
-    let __v_105: G = G::from_u64(256);
-    let __v_106: G = (__v_105 * __v_23);
-    let __v_107: G = G::from_u64(65536);
-    let __v_108: G = (__v_107 * __v_24);
-    let __v_109: G = G::from_u64(16777216);
-    let __v_110: G = (__v_109 * __v_25);
-    let __v_111: G = G::from_u64(4294967296);
-    let __v_112: G = (__v_111 * __v_26);
-    let __v_113: G = G::from_u64(1099511627776);
-    let __v_114: G = (__v_113 * __v_27);
-    let __v_115: G = G::from_u64(281474976710656);
-    let __v_116: G = (__v_115 * __v_28);
-    let __v_117: G = G::from_u64(72057594037927936);
-    let __v_118: G = (__v_117 * __v_29);
-    let __v_119: G = (__v_116 + __v_118);
-    let __v_120: G = (__v_114 + __v_119);
-    let __v_121: G = (__v_112 + __v_120);
-    let __v_122: G = (__v_110 + __v_121);
-    let __v_123: G = (__v_108 + __v_122);
-    let __v_124: G = (__v_106 + __v_123);
-    let __v_125: G = (__v_22 + __v_124);
-    if (__v_125 != __v_1) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None });
+    let __v_103: G = G::from_u64(256);
+    let __v_104: G = (__v_103 * __v_23);
+    let __v_105: G = G::from_u64(65536);
+    let __v_106: G = (__v_105 * __v_24);
+    let __v_107: G = G::from_u64(16777216);
+    let __v_108: G = (__v_107 * __v_25);
+    let __v_109: G = G::from_u64(4294967296);
+    let __v_110: G = (__v_109 * __v_26);
+    let __v_111: G = G::from_u64(1099511627776);
+    let __v_112: G = (__v_111 * __v_27);
+    let __v_113: G = G::from_u64(281474976710656);
+    let __v_114: G = (__v_113 * __v_28);
+    let __v_115: G = G::from_u64(72057594037927936);
+    let __v_116: G = (__v_115 * __v_29);
+    let __v_117: G = (__v_114 + __v_116);
+    let __v_118: G = (__v_112 + __v_117);
+    let __v_119: G = (__v_110 + __v_118);
+    let __v_120: G = (__v_108 + __v_119);
+    let __v_121: G = (__v_106 + __v_120);
+    let __v_122: G = (__v_104 + __v_121);
+    let __v_123: G = (__v_22 + __v_122);
+    if (__v_123 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None });
     }
-    let __v_126: G = G::from_u64(1);
-    let __v_127: G = G::from_u64(1);
-    let __v_128: G = (__v_127 - __v_39);
-    let __v_129: G = (__v_35 * __v_128);
-    let __v_130: G = (__v_126 - __v_129);
-    let __v_131: G = G::from_u64(1);
-    if (__v_130 != __v_131) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_130.as_canonical_u64(), rhs: __v_131.as_canonical_u64(), msg: None });
+    let __v_124: G = G::from_u64(1);
+    let __v_125: G = G::from_u64(1);
+    let __v_126: G = (__v_125 - __v_39);
+    let __v_127: G = (__v_35 * __v_126);
+    let __v_128: G = (__v_124 - __v_127);
+    let __v_129: G = G::from_u64(1);
+    if (__v_128 != __v_129) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_128.as_canonical_u64(), rhs: __v_129.as_canonical_u64(), msg: None });
     }
-    let __v_132: G = G::from_u64(0);
-    let __v_133: G = G::from_u64(256);
-    let __v_134: G = (__v_133 * __v_41);
-    let __v_135: G = G::from_u64(65536);
-    let __v_136: G = (__v_135 * __v_42);
-    let __v_137: G = G::from_u64(16777216);
-    let __v_138: G = (__v_137 * __v_43);
-    let __v_139: G = G::from_u64(4294967296);
-    let __v_140: G = (__v_139 * __v_44);
-    let __v_141: G = G::from_u64(1099511627776);
-    let __v_142: G = (__v_141 * __v_45);
-    let __v_143: G = G::from_u64(281474976710656);
-    let __v_144: G = (__v_143 * __v_46);
-    let __v_145: G = G::from_u64(72057594037927936);
-    let __v_146: G = (__v_145 * __v_47);
-    let __v_147: G = (__v_144 + __v_146);
-    let __v_148: G = (__v_142 + __v_147);
-    let __v_149: G = (__v_140 + __v_148);
-    let __v_150: G = (__v_138 + __v_149);
-    let __v_151: G = (__v_136 + __v_150);
-    let __v_152: G = (__v_134 + __v_151);
-    let __v_153: G = (__v_40 + __v_152);
-    if (__v_153 != __v_2) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_153.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None });
+    let __v_130: G = G::from_u64(256);
+    let __v_131: G = (__v_130 * __v_41);
+    let __v_132: G = G::from_u64(65536);
+    let __v_133: G = (__v_132 * __v_42);
+    let __v_134: G = G::from_u64(16777216);
+    let __v_135: G = (__v_134 * __v_43);
+    let __v_136: G = G::from_u64(4294967296);
+    let __v_137: G = (__v_136 * __v_44);
+    let __v_138: G = G::from_u64(1099511627776);
+    let __v_139: G = (__v_138 * __v_45);
+    let __v_140: G = G::from_u64(281474976710656);
+    let __v_141: G = (__v_140 * __v_46);
+    let __v_142: G = G::from_u64(72057594037927936);
+    let __v_143: G = (__v_142 * __v_47);
+    let __v_144: G = (__v_141 + __v_143);
+    let __v_145: G = (__v_139 + __v_144);
+    let __v_146: G = (__v_137 + __v_145);
+    let __v_147: G = (__v_135 + __v_146);
+    let __v_148: G = (__v_133 + __v_147);
+    let __v_149: G = (__v_131 + __v_148);
+    let __v_150: G = (__v_40 + __v_149);
+    if (__v_150 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None });
     }
-    let __v_154: G = G::from_u64(1);
-    let __v_155: G = G::from_u64(1);
-    let __v_156: G = (__v_155 - __v_57);
-    let __v_157: G = (__v_53 * __v_156);
-    let __v_158: G = (__v_154 - __v_157);
-    let __v_159: G = G::from_u64(1);
-    if (__v_158 != __v_159) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_159.as_canonical_u64(), msg: None });
+    let __v_151: G = G::from_u64(1);
+    let __v_152: G = G::from_u64(1);
+    let __v_153: G = (__v_152 - __v_57);
+    let __v_154: G = (__v_53 * __v_153);
+    let __v_155: G = (__v_151 - __v_154);
+    let __v_156: G = G::from_u64(1);
+    if (__v_155 != __v_156) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_155.as_canonical_u64(), rhs: __v_156.as_canonical_u64(), msg: None });
     }
-    let __v_160: G = G::from_u64(0);
-    let __v_161: G = G::from_u64(256);
-    let __v_162: G = (__v_161 * __v_59);
-    let __v_163: G = G::from_u64(65536);
-    let __v_164: G = (__v_163 * __v_60);
-    let __v_165: G = G::from_u64(16777216);
-    let __v_166: G = (__v_165 * __v_61);
-    let __v_167: G = G::from_u64(4294967296);
-    let __v_168: G = (__v_167 * __v_62);
-    let __v_169: G = G::from_u64(1099511627776);
-    let __v_170: G = (__v_169 * __v_63);
-    let __v_171: G = G::from_u64(281474976710656);
-    let __v_172: G = (__v_171 * __v_64);
-    let __v_173: G = G::from_u64(72057594037927936);
-    let __v_174: G = (__v_173 * __v_65);
-    let __v_175: G = (__v_172 + __v_174);
-    let __v_176: G = (__v_170 + __v_175);
-    let __v_177: G = (__v_168 + __v_176);
-    let __v_178: G = (__v_166 + __v_177);
-    let __v_179: G = (__v_164 + __v_178);
-    let __v_180: G = (__v_162 + __v_179);
-    let __v_181: G = (__v_58 + __v_180);
-    if (__v_181 != __v_3) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
+    let __v_157: G = G::from_u64(256);
+    let __v_158: G = (__v_157 * __v_59);
+    let __v_159: G = G::from_u64(65536);
+    let __v_160: G = (__v_159 * __v_60);
+    let __v_161: G = G::from_u64(16777216);
+    let __v_162: G = (__v_161 * __v_61);
+    let __v_163: G = G::from_u64(4294967296);
+    let __v_164: G = (__v_163 * __v_62);
+    let __v_165: G = G::from_u64(1099511627776);
+    let __v_166: G = (__v_165 * __v_63);
+    let __v_167: G = G::from_u64(281474976710656);
+    let __v_168: G = (__v_167 * __v_64);
+    let __v_169: G = G::from_u64(72057594037927936);
+    let __v_170: G = (__v_169 * __v_65);
+    let __v_171: G = (__v_168 + __v_170);
+    let __v_172: G = (__v_166 + __v_171);
+    let __v_173: G = (__v_164 + __v_172);
+    let __v_174: G = (__v_162 + __v_173);
+    let __v_175: G = (__v_160 + __v_174);
+    let __v_176: G = (__v_158 + __v_175);
+    let __v_177: G = (__v_58 + __v_176);
+    if (__v_177 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_177.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
     }
-    let __v_182: G = G::from_u64(1);
+    let __v_178: G = G::from_u64(1);
+    let __v_179: G = G::from_u64(1);
+    let __v_180: G = (__v_179 - __v_75);
+    let __v_181: G = (__v_71 * __v_180);
+    let __v_182: G = (__v_178 - __v_181);
     let __v_183: G = G::from_u64(1);
-    let __v_184: G = (__v_183 - __v_75);
-    let __v_185: G = (__v_71 * __v_184);
-    let __v_186: G = (__v_182 - __v_185);
-    let __v_187: G = G::from_u64(1);
-    if (__v_186 != __v_187) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: None });
+    if (__v_182 != __v_183) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_182.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: None });
     }
-    let __v_188: G = G::from_u64(1);
-    let __v_189: G = G::from_u64(1);
-    let __v_190: G = { let __values: [G; 10] = [__v_188, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_191: G = { let __values: [G; 10] = [__v_160, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_190]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_192: G = { let __values: [G; 10] = [__v_132, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_191]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_193: G = { let __values: [G; 10] = [__v_104, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_192]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_194: G = { let __values: [G; 10] = [__v_76, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_193]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_137] = [__v_194];
+    let __v_184: G = G::from_u64(0);
+    let __v_185: G = { let __values: [G; 9] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_184]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_186: G = { let __values: [G; 9] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_185]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_187: G = { let __values: [G; 9] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_186]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_188: G = { let __values: [G; 9] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_187]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_137] = [__v_188];
     record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -13356,42 +13287,41 @@ fn aiur_fn_138(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
-    let __v_6: G = __loaded[0];
-    let __v_7: G = __loaded[1];
-    let __v_8: G = __loaded[2];
-    let __v_9: G = __loaded[3];
-    let __v_10: G = __loaded[4];
-    let __v_11: G = __loaded[5];
-    let __v_12: G = __loaded[6];
-    match __v_6.as_canonical_u64() {
-      1u64 => {
+    match __v_5.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_138] = [__v_0, __v_1, __v_5];
         record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_7.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        let __v_9: G = __loaded[3];
+        let __v_10: G = __loaded[4];
+        let __v_11: G = __loaded[5];
+        match __v_6.as_canonical_u64() {
           _ => {
-            let __v_13: G = (__v_7 - __v_2);
-            let __v_14: G = G::from_bool((__v_13 == G::ZERO));
-            match __v_14.as_canonical_u64() {
+            let __v_12: G = (__v_6 - __v_2);
+            let __v_13: G = G::from_bool((__v_12 == G::ZERO));
+            match __v_13.as_canonical_u64() {
               1u64 => {
-                let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_3, __v_4, __v_15]; 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_16: G = __r_arr[0];
-                let __v_17: G = __r_arr[1];
-                let __v_18: G = (__v_16 * __v_10);
-                let __v_19: G = G::from_u64(7);
-                let __v_20: G = (__v_17 * __v_11);
-                let __v_21: G = (__v_19 * __v_20);
-                let __v_22: G = (__v_18 + __v_21);
-                let __v_23: G = (__v_16 * __v_11);
-                let __v_24: G = (__v_17 * __v_10);
-                let __v_25: G = (__v_23 + __v_24);
-                let __v_26: G = (__v_0 + __v_22);
-                let __v_27: G = (__v_1 + __v_25);
-                let __ret: [G; OUT_138] = [__v_26, __v_27, __v_12];
+                let __v_14: G = G::from_u64(1);
+                let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_3, __v_4, __v_14]; 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_15: G = __r_arr[0];
+                let __v_16: G = __r_arr[1];
+                let __v_17: G = (__v_15 * __v_9);
+                let __v_18: G = G::from_u64(7);
+                let __v_19: G = (__v_16 * __v_10);
+                let __v_20: G = (__v_18 * __v_19);
+                let __v_21: G = (__v_17 + __v_20);
+                let __v_22: G = (__v_15 * __v_10);
+                let __v_23: G = (__v_16 * __v_9);
+                let __v_24: G = (__v_22 + __v_23);
+                let __v_25: G = (__v_0 + __v_21);
+                let __v_26: G = (__v_1 + __v_24);
+                let __ret: [G; OUT_138] = [__v_25, __v_26, __v_11];
                 record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
@@ -13404,9 +13334,6 @@ fn aiur_fn_138(
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-      },
     }
   })
 }
@@ -13430,121 +13357,129 @@ fn aiur_fn_139(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-    let __v_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    let __v_12: G = __loaded[3];
-    let __v_13: G = __loaded[4];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __v_14: G = (__v_6 - __v_8);
-        let __v_15: G = G::from_bool((__v_14 == G::ZERO));
-        let __v_16: G = G::from_u64(1);
-        if (__v_15 != __v_16) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None });
+    match __v_4.as_canonical_u64() {
+      0u64 => {
+        let __v_9: G = (__v_6 - __v_8);
+        let __v_10: G = G::from_bool((__v_9 == G::ZERO));
+        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(), msg: None });
         }
         let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__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_17: G = __r_arr[0];
-        let __v_18: G = G::from_u64(0);
-        if (__v_17 != __v_18) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
+        let __v_12: G = __r_arr[0];
+        let __v_13: G = G::from_u64(0);
+        if (__v_12 != __v_13) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None });
         }
         let __ret: [G; OUT_139] = [__v_0, __v_1];
         record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_14: G = __loaded[0];
-        let __v_15: G = __loaded[1];
-        let __v_16: G = __loaded[2];
-        let __v_17: G = __loaded[3];
-        match __v_14.as_canonical_u64() {
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_9: G = __loaded[0];
+        let __v_10: G = __loaded[1];
+        let __v_11: G = __loaded[2];
+        let __v_12: G = __loaded[3];
+        match __v_2.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_18: G = __loaded[0];
-            let __v_19: G = __loaded[1];
-            let __v_20: G = __loaded[2];
-            match __v_18.as_canonical_u64() {
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = G::from_u64(1);
+            if (__v_13 != __v_14) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_139] = [__v_13, __v_13];
+            record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_13: G = __loaded[0];
+            let __v_14: G = __loaded[1];
+            let __v_15: G = __loaded[2];
+            match __v_3.as_canonical_u64() {
               0u64 => {
-                match __v_10.as_canonical_u64() {
+                let __v_16: G = G::from_u64(0);
+                let __v_17: G = G::from_u64(1);
+                if (__v_16 != __v_17) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                }
+                let __ret: [G; OUT_139] = [__v_16, __v_16];
+                record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                let __v_16: G = __loaded[0];
+                let __v_17: G = __loaded[1];
+                match __v_9.as_canonical_u64() {
                   _ => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                    let __v_21: G = __loaded[0];
-                    let __v_22: G = __loaded[1];
-                    let __v_23: G = __loaded[2];
-                    match __v_21.as_canonical_u64() {
+                    match __v_5.as_canonical_u64() {
                       0u64 => {
-                        let __v_24: G = G::from_u64(1);
-                        let __v_25: G = (__v_6 - __v_24);
-                        let __v_26: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_11, __v_26]; 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_27: G = __r_arr[0];
-                        let __v_28: G = __r_arr[1];
-                        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_22, __v_0, __v_1, __v_27, __v_28]; 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_18: G = G::from_u64(0);
+                        let __v_19: G = G::from_u64(1);
+                        if (__v_18 != __v_19) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                        }
+                        let __ret: [G; OUT_139] = [__v_18, __v_18];
+                        record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                        let __v_18: G = __loaded[0];
+                        let __v_19: G = __loaded[1];
+                        let __v_20: G = G::from_u64(1);
+                        let __v_21: G = (__v_6 - __v_20);
+                        let __v_22: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_10, __v_22]; 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_23: G = __r_arr[0];
+                        let __v_24: G = __r_arr[1];
+                        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_18, __v_0, __v_1, __v_23, __v_24]; 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_25: G = __r_arr[0];
+                        let __v_26: G = __r_arr[1];
+                        let __v_27: G = __r_arr[2];
+                        let __v_28: G = __r_arr[3];
+                        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_19, __v_21, __v_13, __v_14, __v_25, __v_26, __v_27, __v_28]; 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_29: G = __r_arr[0];
                         let __v_30: G = __r_arr[1];
-                        let __v_31: G = __r_arr[2];
-                        let __v_32: G = __r_arr[3];
-                        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_23, __v_25, __v_15, __v_16, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_33: G = __r_arr[0];
-                        let __v_34: G = __r_arr[1];
-                        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_33, __v_34, __v_25, __v_15, __v_16, __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_35: G = __r_arr[0];
-                        let __v_36: G = __r_arr[1];
-                        let __v_37: G = __r_arr[2];
-                        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__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 __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(), msg: None });
+                        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_29, __v_30, __v_21, __v_13, __v_14, __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_31: G = __r_arr[0];
+                        let __v_32: G = __r_arr[1];
+                        let __v_33: G = __r_arr[2];
+                        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !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_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(), msg: None });
                         }
-                        let __v_40: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_29, __v_30, __v_31, __v_32]; 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_137] = { let __args: [G; IN_137] = [__v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } };
+                        let __v_36: G = __r_arr[0];
+                        let __v_37: G = G::from_u64(0);
+                        let __v_38: G = { let __values: [G; 2] = [__v_36, __v_37]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_39: G = G::from_u64(0);
+                        let __v_40: G = { let __values: [G; 2] = [__v_21, __v_39]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_16, __v_38, __v_40, __v_19, __v_11, __v_21]; 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_41: G = __r_arr[0];
                         let __v_42: G = G::from_u64(1);
-                        let __v_43: G = G::from_u64(1);
-                        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_45: G = { let __values: [G; 3] = [__v_40, __v_41, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_46: G = G::from_u64(0);
-                        let __v_47: G = G::from_u64(1);
-                        let __v_48: G = G::from_u64(1);
-                        let __v_49: G = { let __values: [G; 3] = [__v_47, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_50: G = { let __values: [G; 3] = [__v_46, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_19, __v_45, __v_50, __v_23, __v_12, __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 __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(), msg: None });
+                        if (__v_41 != __v_42) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None });
                         }
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_35, __v_36, __v_17, __v_20, __v_13, __v_23, __v_25, __v_37, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_53: G = __r_arr[0];
-                        let __v_54: G = __r_arr[1];
-                        let __ret: [G; OUT_139] = [__v_53, __v_54];
+                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_31, __v_32, __v_15, __v_17, __v_12, __v_19, __v_21, __v_33, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } };
+                        let __v_43: G = __r_arr[0];
+                        let __v_44: G = __r_arr[1];
+                        let __ret: [G; OUT_139] = [__v_43, __v_44];
                         record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
-                      },
                     }
                   },
                 }
               },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
-              },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-      },
     }
   })
 }
@@ -13619,121 +13554,127 @@ fn aiur_fn_140(
                     let __v_41: G = __r_arr[0];
                     let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_41, __v_19]; 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_42: G = __r_arr[0];
-                    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_41.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
-                    let __v_43: G = __loaded[0];
-                    let __v_44: G = __loaded[1];
-                    let __v_45: G = __loaded[2];
-                    let __v_46: G = __loaded[3];
-                    let __v_47: G = __loaded[4];
-                    let __v_48: G = __loaded[5];
-                    let __v_49: G = __loaded[6];
-                    match __v_43.as_canonical_u64() {
+                    match __v_41.as_canonical_u64() {
                       0u64 => {
-                        match __v_44.as_canonical_u64() {
+                        let __v_43: G = G::from_u64(0);
+                        let __v_44: G = G::from_u64(1);
+                        if (__v_43 != __v_44) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+                        }
+                        let __ret: [G; OUT_140] = [__v_43];
+                        record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_41.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).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_43: G = __loaded[0];
+                        let __v_44: G = __loaded[1];
+                        let __v_45: G = __loaded[2];
+                        let __v_46: G = __loaded[3];
+                        let __v_47: G = __loaded[4];
+                        let __v_48: G = __loaded[5];
+                        match __v_43.as_canonical_u64() {
                           _ => {
-                            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_47, __v_48, __v_21, __v_22, __v_2, __v_0, __v_20, __v_49, __v_19]; 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_50: G = __r_arr[0];
-                            let __v_51: G = __r_arr[1];
-                            let __v_52: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_23, __v_52]; 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_53: G = __r_arr[0];
-                            let __v_54: G = __r_arr[1];
+                            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_46, __v_47, __v_21, __v_22, __v_2, __v_0, __v_20, __v_48, __v_19]; 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_49: G = __r_arr[0];
+                            let __v_50: G = __r_arr[1];
+                            let __v_51: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_23, __v_51]; 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_52: G = __r_arr[0];
+                            let __v_53: G = __r_arr[1];
                             let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } };
-                            let __v_55: G = __r_arr[0];
-                            let __v_56: G = (__v_55 - __v_24);
-                            let __v_57: G = G::from_bool((__v_56 == G::ZERO));
-                            let __v_58: G = G::from_u64(1);
-                            if (__v_57 != __v_58) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None });
+                            let __v_54: G = __r_arr[0];
+                            let __v_55: G = (__v_54 - __v_24);
+                            let __v_56: G = G::from_bool((__v_55 == G::ZERO));
+                            let __v_57: G = G::from_u64(1);
+                            if (__v_56 != __v_57) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: None });
                             }
                             let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
-                            let __v_59: G = __r_arr[0];
-                            let __v_60: G = G::from_u64(3);
+                            let __v_58: G = __r_arr[0];
+                            let __v_59: G = G::from_u64(3);
                             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 __v_61: G = __r_arr[0];
-                            let __v_62: G = (__v_60 + __v_61);
-                            let __v_63: G = (__v_59 - __v_62);
-                            let __v_64: G = G::from_bool((__v_63 == G::ZERO));
-                            let __v_65: G = G::from_u64(1);
-                            if (__v_64 != __v_65) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None });
+                            let __v_60: G = __r_arr[0];
+                            let __v_61: G = (__v_59 + __v_60);
+                            let __v_62: G = (__v_58 - __v_61);
+                            let __v_63: G = G::from_bool((__v_62 == G::ZERO));
+                            let __v_64: G = G::from_u64(1);
+                            if (__v_63 != __v_64) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_64.as_canonical_u64(), msg: None });
                             }
-                            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_27]; 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_66: G = __r_arr[0];
-                            let __v_67: G = (__v_66 - __v_18);
-                            let __v_68: G = G::from_bool((__v_67 == G::ZERO));
-                            let __v_69: G = G::from_u64(1);
-                            if (__v_68 != __v_69) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: None });
+                            let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_27]; 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_65: G = __r_arr[0];
+                            let __v_66: G = (__v_65 - __v_18);
+                            let __v_67: G = G::from_bool((__v_66 == G::ZERO));
+                            let __v_68: G = G::from_u64(1);
+                            if (__v_67 != __v_68) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_68.as_canonical_u64(), msg: None });
                             }
-                            let __v_70: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15, __v_19, __v_18, __v_70]; 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_69: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15, __v_19, __v_18, __v_69]; 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_70: G = __r_arr[0];
+                            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_10, __v_27, __v_70, __v_0, __v_28, __v_20]; 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_71: G = __r_arr[0];
-                            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_10, __v_27, __v_71, __v_0, __v_28, __v_20]; 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_72: G = __r_arr[0];
-                            let __v_73: G = G::from_u64(1);
-                            if (__v_72 != __v_73) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None });
+                            let __v_72: G = G::from_u64(1);
+                            if (__v_71 != __v_72) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_72.as_canonical_u64(), msg: None });
                             }
-                            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_74: G = __r_arr[0];
-                            let __v_75: G = (__v_74 - __v_18);
-                            let __v_76: G = G::from_bool((__v_75 == G::ZERO));
-                            let __v_77: G = G::from_u64(1);
-                            if (__v_76 != __v_77) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
+                            let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_32]; 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_73: G = __r_arr[0];
+                            let __v_74: G = (__v_73 - __v_18);
+                            let __v_75: G = G::from_bool((__v_74 == G::ZERO));
+                            let __v_76: G = G::from_u64(1);
+                            if (__v_75 != __v_76) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_76.as_canonical_u64(), msg: None });
                             }
-                            let __v_78: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15, __v_19, __v_18, __v_78]; 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_77: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15, __v_19, __v_18, __v_77]; 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_78: G = __r_arr[0];
+                            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_11, __v_32, __v_78, __v_0, __v_33, __v_20]; 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_79: G = __r_arr[0];
-                            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_11, __v_32, __v_79, __v_0, __v_33, __v_20]; 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_80: G = __r_arr[0];
-                            let __v_81: G = G::from_u64(1);
-                            if (__v_80 != __v_81) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None });
+                            let __v_80: G = G::from_u64(1);
+                            if (__v_79 != __v_80) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_80.as_canonical_u64(), msg: None });
                             }
-                            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_37]; 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_82: G = __r_arr[0];
-                            let __v_83: G = (__v_82 - __v_18);
-                            let __v_84: G = G::from_bool((__v_83 == G::ZERO));
-                            let __v_85: G = G::from_u64(1);
-                            if (__v_84 != __v_85) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_85.as_canonical_u64(), msg: None });
+                            let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_37]; 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_81: G = __r_arr[0];
+                            let __v_82: G = (__v_81 - __v_18);
+                            let __v_83: G = G::from_bool((__v_82 == G::ZERO));
+                            let __v_84: G = G::from_u64(1);
+                            if (__v_83 != __v_84) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_83.as_canonical_u64(), rhs: __v_84.as_canonical_u64(), msg: None });
                             }
-                            let __v_86: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15, __v_19, __v_18, __v_86]; 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_85: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15, __v_19, __v_18, __v_85]; 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_86: G = __r_arr[0];
+                            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_12, __v_37, __v_86, __v_0, __v_38, __v_20]; 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_87: G = __r_arr[0];
-                            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_12, __v_37, __v_87, __v_0, __v_38, __v_20]; 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_88: G = __r_arr[0];
-                            let __v_89: G = G::from_u64(1);
-                            if (__v_88 != __v_89) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_89.as_canonical_u64(), msg: None });
+                            let __v_88: G = G::from_u64(1);
+                            if (__v_87 != __v_88) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None });
                             }
-                            let __v_90: G = (__v_44 - __v_20);
-                            let __v_91: G = G::from_bool((__v_90 == G::ZERO));
-                            let __v_92: G = G::from_u64(1);
-                            if (__v_91 != __v_92) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_91.as_canonical_u64(), rhs: __v_92.as_canonical_u64(), msg: None });
+                            let __v_89: G = (__v_43 - __v_20);
+                            let __v_90: G = G::from_bool((__v_89 == G::ZERO));
+                            let __v_91: G = G::from_u64(1);
+                            if (__v_90 != __v_91) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_91.as_canonical_u64(), msg: None });
                             }
-                            let __v_93: G = (__v_53 - __v_50);
-                            let __v_94: G = G::from_bool((__v_93 == G::ZERO));
-                            let __v_95: G = (__v_54 - __v_51);
-                            let __v_96: G = G::from_bool((__v_95 == G::ZERO));
-                            let __v_97: G = (__v_94 * __v_96);
-                            let __v_98: G = G::from_u64(1);
-                            if (__v_97 != __v_98) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_98.as_canonical_u64(), msg: None });
+                            let __v_92: G = (__v_52 - __v_49);
+                            let __v_93: G = G::from_bool((__v_92 == G::ZERO));
+                            let __v_94: G = (__v_53 - __v_50);
+                            let __v_95: G = G::from_bool((__v_94 == G::ZERO));
+                            let __v_96: G = (__v_93 * __v_95);
+                            let __v_97: G = G::from_u64(1);
+                            if (__v_96 != __v_97) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_97.as_canonical_u64(), msg: None });
                             }
-                            let __v_99: G = G::from_u64(1);
-                            let __ret: [G; OUT_140] = [__v_99];
+                            let __v_98: G = G::from_u64(1);
+                            let __ret: [G; OUT_140] = [__v_98];
                             record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64()));
-                      },
                     }
                   },
                 }
@@ -13781,34 +13722,30 @@ fn aiur_fn_141(
     let __v_22: G = inp[22];
     let __v_23: G = inp[23];
     let __v_24: G = inp[24];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_25: G = __loaded[0];
-    let __v_26: G = __loaded[1];
-    let __v_27: G = __loaded[2];
-    let __v_28: G = __loaded[3];
-    match __v_25.as_canonical_u64() {
-      1u64 => {
-        let __v_29: G = G::from_u64(1);
-        let __ret: [G; OUT_141] = [__v_29];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_25: G = G::from_u64(1);
+        let __ret: [G; OUT_141] = [__v_25];
         record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
+      _ => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_25: G = __loaded[0];
+        let __v_26: G = __loaded[1];
+        let __v_27: G = __loaded[2];
         let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_1, __v_20]; 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_29: G = __r_arr[0];
-        let __v_30: G = __r_arr[1];
-        let __v_31: G = __r_arr[2];
-        let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_28: G = __r_arr[0];
+        let __v_29: G = __r_arr[1];
+        let __v_30: G = __r_arr[2];
+        let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_28, __v_25, __v_26, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __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[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_31: G = __r_arr[0];
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_29, __v_30, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } };
         let __v_32: G = __r_arr[0];
-        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_33: G = __r_arr[0];
-        let __ret: [G; OUT_141] = [__v_33];
+        let __ret: [G; OUT_141] = [__v_32];
         record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
-      },
     }
   })
 }
@@ -13856,126 +13793,120 @@ fn aiur_fn_142(
     let __v_30: G = inp[30];
     match __v_6.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_6]; 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_31: G = __r_arr[0];
-        let __v_32: G = G::from_u64(1);
-        let __v_33: G = G::from_u64(1);
-        let __v_34: G = { let __values: [G; 3] = [__v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_5, __v_34]; 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_32: G = G::from_u64(0);
+        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_5, __v_32]; 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_33: G = __r_arr[0];
+        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3, __v_33]; 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 __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_2, __v_34]; 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_35: G = __r_arr[0];
-        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3, __v_35]; 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_117] = { let __args: [G; IN_117] = [__v_1, __v_35]; 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_36: G = __r_arr[0];
-        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_2, __v_36]; 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_204] = { let __args: [G; IN_204] = [__v_0, __v_36]; 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_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_1, __v_37]; 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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_38]; 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_38: G = G::from_u64(0);
+        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_37, __v_38]; 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_39: G = __r_arr[0];
-        let __v_40: G = G::from_u64(1);
-        let __v_41: G = G::from_u64(1);
-        let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-        let __v_43: G = __r_arr[0];
-        let __v_44: G = __r_arr[1];
-        let __v_45: G = __r_arr[2];
-        let __v_46: G = __r_arr[3];
-        let __v_47: G = __r_arr[4];
-        let __v_48: G = __r_arr[5];
-        let __v_49: G = __r_arr[6];
-        let __v_50: G = __r_arr[7];
-        let __v_51: G = __r_arr[8];
-        let __v_52: G = __r_arr[9];
-        let __v_53: G = __r_arr[10];
-        let __v_54: G = __r_arr[11];
-        let __v_55: G = __r_arr[12];
-        let __v_56: G = __r_arr[13];
-        let __v_57: G = __r_arr[14];
-        let __v_58: G = __r_arr[15];
-        let __v_59: G = __r_arr[16];
-        let __v_60: G = __r_arr[17];
-        let __v_61: G = G::from_u64(256);
-        let __v_62: G = (__v_61 * __v_44);
-        let __v_63: G = G::from_u64(65536);
-        let __v_64: G = (__v_63 * __v_45);
-        let __v_65: G = G::from_u64(16777216);
-        let __v_66: G = (__v_65 * __v_46);
-        let __v_67: G = G::from_u64(4294967296);
-        let __v_68: G = (__v_67 * __v_47);
-        let __v_69: G = G::from_u64(1099511627776);
-        let __v_70: G = (__v_69 * __v_48);
-        let __v_71: G = G::from_u64(281474976710656);
-        let __v_72: G = (__v_71 * __v_49);
-        let __v_73: G = G::from_u64(72057594037927936);
-        let __v_74: G = (__v_73 * __v_50);
-        let __v_75: G = (__v_72 + __v_74);
-        let __v_76: G = (__v_70 + __v_75);
-        let __v_77: G = (__v_68 + __v_76);
-        let __v_78: G = (__v_66 + __v_77);
-        let __v_79: G = (__v_64 + __v_78);
-        let __v_80: G = (__v_62 + __v_79);
-        let __v_81: G = (__v_43 + __v_80);
-        let __v_82: G = G::from_u64(256);
-        let __v_83: G = (__v_82 * __v_52);
-        let __v_84: G = G::from_u64(65536);
-        let __v_85: G = (__v_84 * __v_53);
-        let __v_86: G = G::from_u64(16777216);
-        let __v_87: G = (__v_86 * __v_54);
-        let __v_88: G = G::from_u64(4294967296);
-        let __v_89: G = (__v_88 * __v_55);
-        let __v_90: G = G::from_u64(1099511627776);
-        let __v_91: G = (__v_90 * __v_56);
-        let __v_92: G = G::from_u64(281474976710656);
-        let __v_93: G = (__v_92 * __v_57);
-        let __v_94: G = G::from_u64(72057594037927936);
-        let __v_95: G = (__v_94 * __v_58);
-        let __v_96: G = (__v_93 + __v_95);
-        let __v_97: G = (__v_91 + __v_96);
-        let __v_98: G = (__v_89 + __v_97);
-        let __v_99: G = (__v_87 + __v_98);
-        let __v_100: G = (__v_85 + __v_99);
-        let __v_101: G = (__v_83 + __v_100);
-        let __v_102: G = (__v_51 + __v_101);
-        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_59, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+        let __v_40: G = __r_arr[1];
+        let __v_41: G = __r_arr[2];
+        let __v_42: G = __r_arr[3];
+        let __v_43: G = __r_arr[4];
+        let __v_44: G = __r_arr[5];
+        let __v_45: G = __r_arr[6];
+        let __v_46: G = __r_arr[7];
+        let __v_47: G = __r_arr[8];
+        let __v_48: G = __r_arr[9];
+        let __v_49: G = __r_arr[10];
+        let __v_50: G = __r_arr[11];
+        let __v_51: G = __r_arr[12];
+        let __v_52: G = __r_arr[13];
+        let __v_53: G = __r_arr[14];
+        let __v_54: G = __r_arr[15];
+        let __v_55: G = __r_arr[16];
+        let __v_56: G = __r_arr[17];
+        let __v_57: G = G::from_u64(256);
+        let __v_58: G = (__v_57 * __v_40);
+        let __v_59: G = G::from_u64(65536);
+        let __v_60: G = (__v_59 * __v_41);
+        let __v_61: G = G::from_u64(16777216);
+        let __v_62: G = (__v_61 * __v_42);
+        let __v_63: G = G::from_u64(4294967296);
+        let __v_64: G = (__v_63 * __v_43);
+        let __v_65: G = G::from_u64(1099511627776);
+        let __v_66: G = (__v_65 * __v_44);
+        let __v_67: G = G::from_u64(281474976710656);
+        let __v_68: G = (__v_67 * __v_45);
+        let __v_69: G = G::from_u64(72057594037927936);
+        let __v_70: G = (__v_69 * __v_46);
+        let __v_71: G = (__v_68 + __v_70);
+        let __v_72: G = (__v_66 + __v_71);
+        let __v_73: G = (__v_64 + __v_72);
+        let __v_74: G = (__v_62 + __v_73);
+        let __v_75: G = (__v_60 + __v_74);
+        let __v_76: G = (__v_58 + __v_75);
+        let __v_77: G = (__v_39 + __v_76);
+        let __v_78: G = G::from_u64(256);
+        let __v_79: G = (__v_78 * __v_48);
+        let __v_80: G = G::from_u64(65536);
+        let __v_81: G = (__v_80 * __v_49);
+        let __v_82: G = G::from_u64(16777216);
+        let __v_83: G = (__v_82 * __v_50);
+        let __v_84: G = G::from_u64(4294967296);
+        let __v_85: G = (__v_84 * __v_51);
+        let __v_86: G = G::from_u64(1099511627776);
+        let __v_87: G = (__v_86 * __v_52);
+        let __v_88: G = G::from_u64(281474976710656);
+        let __v_89: G = (__v_88 * __v_53);
+        let __v_90: G = G::from_u64(72057594037927936);
+        let __v_91: G = (__v_90 * __v_54);
+        let __v_92: G = (__v_89 + __v_91);
+        let __v_93: G = (__v_87 + __v_92);
+        let __v_94: G = (__v_85 + __v_93);
+        let __v_95: G = (__v_83 + __v_94);
+        let __v_96: G = (__v_81 + __v_95);
+        let __v_97: G = (__v_79 + __v_96);
+        let __v_98: G = (__v_47 + __v_97);
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_55, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+        let __v_99: G = __r_arr[0];
+        let __v_100: G = __r_arr[1];
+        let __v_101: G = G::from_u64(0);
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_9, __v_101]; 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_102: G = __r_arr[0];
+        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_100, __v_102]; 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_103: G = __r_arr[0];
-        let __v_104: G = __r_arr[1];
-        let __v_105: G = G::from_u64(1);
-        let __v_106: G = G::from_u64(1);
-        let __v_107: G = { let __values: [G; 3] = [__v_105, __v_106, __v_106]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_9, __v_107]; 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_108: G = __r_arr[0];
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_104, __v_108]; 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_109: G = __r_arr[0];
-        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_109, __v_6]; 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_110: G = __r_arr[0];
-        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_110, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_111: G = __r_arr[0];
-        let __v_112: G = __r_arr[1];
-        let __v_113: G = (__v_31 + __v_27);
+        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_103, __v_6]; 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_104: G = __r_arr[0];
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_104, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_105: G = __r_arr[0];
+        let __v_106: G = __r_arr[1];
+        let __v_107: G = (__v_31 + __v_27);
         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 __v_114: G = __r_arr[0];
-        let __v_115: G = (__v_114 - __v_31);
-        let __v_116: G = G::from_bool((__v_115 == G::ZERO));
-        let __v_117: G = G::from_u64(1);
-        if (__v_116 != __v_117) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_116.as_canonical_u64(), rhs: __v_117.as_canonical_u64(), msg: None });
+        let __v_108: G = __r_arr[0];
+        let __v_109: G = (__v_108 - __v_31);
+        let __v_110: G = G::from_bool((__v_109 == G::ZERO));
+        let __v_111: G = G::from_u64(1);
+        if (__v_110 != __v_111) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_110.as_canonical_u64(), rhs: __v_111.as_canonical_u64(), msg: None });
         }
         let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8]; 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_118: G = __r_arr[0];
-        let __v_119: G = (__v_118 - __v_28);
-        let __v_120: G = G::from_bool((__v_119 == G::ZERO));
-        let __v_121: G = G::from_u64(1);
-        if (__v_120 != __v_121) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_120.as_canonical_u64(), rhs: __v_121.as_canonical_u64(), msg: None });
+        let __v_112: G = __r_arr[0];
+        let __v_113: G = (__v_112 - __v_28);
+        let __v_114: G = G::from_bool((__v_113 == G::ZERO));
+        let __v_115: G = G::from_u64(1);
+        if (__v_114 != __v_115) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_114.as_canonical_u64(), rhs: __v_115.as_canonical_u64(), msg: None });
         }
         let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9]; 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_122: G = __r_arr[0];
-        let __v_123: G = G::from_u64(1);
-        if (__v_122 != __v_123) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_122.as_canonical_u64(), rhs: __v_123.as_canonical_u64(), msg: None });
+        let __v_116: G = __r_arr[0];
+        let __v_117: G = G::from_u64(1);
+        if (__v_116 != __v_117) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_116.as_canonical_u64(), rhs: __v_117.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_111, __v_112, __v_8, __v_81, __v_102, __v_1, __v_2, __v_3, __v_4, __v_5, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_113, __v_103, __v_6, __v_9, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_124: G = __r_arr[0];
-        let __ret: [G; OUT_142] = [__v_124];
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_105, __v_106, __v_8, __v_77, __v_98, __v_1, __v_2, __v_3, __v_4, __v_5, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_107, __v_99, __v_6, __v_9, __v_31]; 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_118: G = __r_arr[0];
+        let __ret: [G; OUT_142] = [__v_118];
         record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -14015,44 +13946,35 @@ fn aiur_fn_144(
 ) -> Result<[G; OUT_144], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_144] = [__v_5];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_144] = [__v_1];
         record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        let __v_8: G = __loaded[3];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_144] = [__v_9];
+      _ => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        match __v_3.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_1, __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_4: G = __r_arr[0];
+            let __ret: [G; OUT_144] = [__v_4];
             record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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_9: G = __r_arr[0];
-            let __ret: [G; OUT_144] = [__v_9];
+            let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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_4: G = __r_arr[0];
+            let __ret: [G; OUT_144] = [__v_4];
             record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -14076,23 +13998,15 @@ fn aiur_fn_145(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __v_9: G = G::from_u64(0);
-    let __v_10: G = G::from_u64(0);
-    let __v_11: G = G::from_u64(0);
-    let __v_12: G = G::from_u64(0);
-    let __v_13: G = G::from_u64(0);
-    let __v_14: G = G::from_u64(0);
-    let __v_15: G = G::from_u64(0);
-    let __v_16: G = G::from_u64(0);
-    let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_145] = [__v_24];
+    let __v_9: G = { let __values: [G; 2] = [__v_7, __v_8]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_10: G = { let __values: [G; 2] = [__v_6, __v_9]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_11: G = { let __values: [G; 2] = [__v_5, __v_10]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_12: G = { let __values: [G; 2] = [__v_4, __v_11]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_13: G = { let __values: [G; 2] = [__v_3, __v_12]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_14: G = { let __values: [G; 2] = [__v_2, __v_13]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_15: G = { let __values: [G; 2] = [__v_1, __v_14]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_16: G = { let __values: [G; 2] = [__v_0, __v_15]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_145] = [__v_16];
     record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -14167,59 +14081,55 @@ fn aiur_fn_147(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: G = __loaded[31];
-    let __v_34: G = __loaded[32];
-    let __v_35: G = __loaded[33];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_147] = [__v_1];
         record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_35, __v_1]; 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 __loaded: [G; 33] = { let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 33 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 33] = __args[..33].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __v_11: G = __loaded[9];
+        let __v_12: G = __loaded[10];
+        let __v_13: G = __loaded[11];
+        let __v_14: G = __loaded[12];
+        let __v_15: G = __loaded[13];
+        let __v_16: G = __loaded[14];
+        let __v_17: G = __loaded[15];
+        let __v_18: G = __loaded[16];
+        let __v_19: G = __loaded[17];
+        let __v_20: G = __loaded[18];
+        let __v_21: G = __loaded[19];
+        let __v_22: G = __loaded[20];
+        let __v_23: G = __loaded[21];
+        let __v_24: G = __loaded[22];
+        let __v_25: G = __loaded[23];
+        let __v_26: G = __loaded[24];
+        let __v_27: G = __loaded[25];
+        let __v_28: G = __loaded[26];
+        let __v_29: G = __loaded[27];
+        let __v_30: G = __loaded[28];
+        let __v_31: G = __loaded[29];
+        let __v_32: G = __loaded[30];
+        let __v_33: G = __loaded[31];
+        let __v_34: G = __loaded[32];
+        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_34, __v_1]; 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_35: G = __r_arr[0];
+        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_35]; 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_36: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_37: G = __r_arr[0];
-        let __ret: [G; OUT_147] = [__v_37];
+        let __ret: [G; OUT_147] = [__v_36];
         record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -14236,35 +14146,31 @@ fn aiur_fn_148(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_148] = [__v_1];
         record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = G::from_u64(0);
-        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_148] = { let __args: [G; IN_148] = [__v_3, __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 __v_11: G = __r_arr[0];
+        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_2, __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[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_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_148] = [__v_13];
+        let __ret: [G; OUT_148] = [__v_12];
         record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -14281,77 +14187,75 @@ fn aiur_fn_149(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
+    match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_149] = [__v_3, __v_0, __v_4];
-        record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
         let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } else { aiur_fn_59(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = __r_arr[1];
-        let __v_7: G = __r_arr[2];
-        let __v_8: G = __r_arr[3];
-        let __v_9: G = __r_arr[4];
-        let __v_10: G = __r_arr[5];
-        let __v_11: G = __r_arr[6];
-        let __v_12: G = __r_arr[7];
-        let __v_13: G = __r_arr[8];
-        let __v_14: G = __r_arr[9];
-        let __v_15: G = __r_arr[10];
-        let __v_16: G = __r_arr[11];
-        let __v_17: G = __r_arr[12];
-        let __v_18: G = __r_arr[13];
-        let __v_19: G = __r_arr[14];
-        let __v_20: G = __r_arr[15];
-        let __v_21: G = __r_arr[16];
-        let __v_22: G = __r_arr[17];
-        let __v_23: G = __r_arr[18];
-        let __v_24: G = __r_arr[19];
-        let __v_25: G = __r_arr[20];
-        let __v_26: G = __r_arr[21];
-        let __v_27: G = __r_arr[22];
-        let __v_28: G = __r_arr[23];
-        let __v_29: G = __r_arr[24];
-        let __v_30: G = __r_arr[25];
-        let __v_31: G = __r_arr[26];
-        let __v_32: G = __r_arr[27];
-        let __v_33: G = __r_arr[28];
-        let __v_34: G = __r_arr[29];
-        let __v_35: G = __r_arr[30];
-        let __v_36: G = __r_arr[31];
-        let __v_37: G = G::from_u64(1);
-        let __v_38: G = G::from_u64(1);
-        let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_40: G = __r_arr[0];
-        let __v_41: G = G::from_u64(1);
-        let __v_42: G = G::from_u64(1);
-        let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_40, __v_43]; 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_44: G = __r_arr[0];
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_44.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_45: G = __loaded[0];
-        let __v_46: G = __loaded[1];
-        let __v_47: G = __loaded[2];
-        match __v_45.as_canonical_u64() {
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __v_11: G = __r_arr[9];
+        let __v_12: G = __r_arr[10];
+        let __v_13: G = __r_arr[11];
+        let __v_14: G = __r_arr[12];
+        let __v_15: G = __r_arr[13];
+        let __v_16: G = __r_arr[14];
+        let __v_17: G = __r_arr[15];
+        let __v_18: G = __r_arr[16];
+        let __v_19: G = __r_arr[17];
+        let __v_20: G = __r_arr[18];
+        let __v_21: G = __r_arr[19];
+        let __v_22: G = __r_arr[20];
+        let __v_23: G = __r_arr[21];
+        let __v_24: G = __r_arr[22];
+        let __v_25: G = __r_arr[23];
+        let __v_26: G = __r_arr[24];
+        let __v_27: G = __r_arr[25];
+        let __v_28: G = __r_arr[26];
+        let __v_29: G = __r_arr[27];
+        let __v_30: G = __r_arr[28];
+        let __v_31: G = __r_arr[29];
+        let __v_32: G = __r_arr[30];
+        let __v_33: G = __r_arr[31];
+        let __v_34: G = G::from_u64(0);
+        let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __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 __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_35: G = __r_arr[0];
+        let __v_36: G = G::from_u64(0);
+        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_35, __v_36]; 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_37: G = __r_arr[0];
+        match __v_37.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_149] = [__v_46, __v_40, __v_47];
+            let __v_38: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_149] = [__v_38, __v_38, __v_38];
             record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_38: G = __loaded[0];
+            let __v_39: G = __loaded[1];
+            let __ret: [G; OUT_149] = [__v_38, __v_35, __v_39];
+            record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __ret: [G; OUT_149] = [__v_2, __v_0, __v_3];
+        record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -14601,26 +14505,24 @@ fn aiur_fn_153(
     let __v_69: G = __b1_out[5];
     let __v_70: G = __b1_out[6];
     let __v_71: G = __b1_out[7];
-    let __v_72: G = G::from_u64(1);
-    let __v_73: G = G::from_u64(1);
-    let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_72: G = G::from_u64(0);
+    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_73: G = __r_arr[0];
+    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_73]; 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_74: G = __r_arr[0];
+    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_74]; 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_75: G = __r_arr[0];
-    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_145] = { let __args: [G; IN_145] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_75]; 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_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_145] = { let __args: [G; IN_145] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_76]; 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_77: G = __r_arr[0];
-    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_145] = { let __args: [G; IN_145] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_77]; 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_78: G = __r_arr[0];
-    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_145] = { let __args: [G; IN_145] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_78]; 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_79: G = __r_arr[0];
-    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_145] = { let __args: [G; IN_145] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_79]; 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_80: G = __r_arr[0];
-    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_81: G = __r_arr[0];
-    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_81]; 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_82: G = __r_arr[0];
-    let __ret: [G; OUT_153] = [__v_82];
+    let __ret: [G; OUT_153] = [__v_80];
     record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -14640,32 +14542,35 @@ fn aiur_fn_154(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_154] = [__v_4];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_154] = [__v_2];
         record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_2: G = __loaded[0];
-        let __v_3: G = __loaded[1];
-        let __v_4: G = __loaded[2];
-        match __v_2.as_canonical_u64() {
+        match __v_0.as_canonical_u64() {
           0u64 => {
-            let __v_5: G = G::from_u64(0);
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_4, __v_7]; 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_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_154] = [__v_9];
+            let __v_2: G = G::from_u64(0);
+            let __v_3: G = G::from_u64(1);
+            if (__v_2 != __v_3) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_154] = [__v_2];
             record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_2: G = __loaded[0];
+            let __v_3: G = __loaded[1];
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = (__v_1 - __v_4);
+            let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
+            let __v_7: G = { let __values: [G; 2] = [__v_2, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_154] = [__v_7];
+            record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
@@ -14726,14 +14631,12 @@ fn aiur_fn_156(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __v_9: G = G::from_u64(1);
-    let __v_10: G = G::from_u64(1);
-    let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_12]; 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_13: G = __r_arr[0];
-    let __ret: [G; OUT_156] = [__v_13];
+    let __v_9: G = G::from_u64(0);
+    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__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[145].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_10]; 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_11: G = __r_arr[0];
+    let __ret: [G; OUT_156] = [__v_11];
     record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -14751,14 +14654,12 @@ fn aiur_fn_157(
   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_147] = { let __args: [G; IN_147] = [__v_1, __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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_5]; 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_6: G = __r_arr[0];
-    let __ret: [G; OUT_157] = [__v_6];
+    let __v_2: G = G::from_u64(0);
+    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_1, __v_2]; 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_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __ret: [G; OUT_157] = [__v_4];
     record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -14776,35 +14677,31 @@ fn aiur_fn_158(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_158] = [__v_1];
         record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !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 __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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_10, __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_11: G = __r_arr[0];
+        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; 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_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__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[145].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_158] = [__v_13];
+        let __ret: [G; OUT_158] = [__v_12];
         record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -14821,39 +14718,35 @@ fn aiur_fn_159(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_159] = [__v_1];
         record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = __r_arr[1];
-        let __v_7: G = __r_arr[2];
-        let __v_8: G = __r_arr[3];
-        let __v_9: G = __r_arr[4];
-        let __v_10: G = __r_arr[5];
-        let __v_11: G = __r_arr[6];
-        let __v_12: G = __r_arr[7];
-        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_4, __v_1]; 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 __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        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 __v_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __v_6: G = __r_arr[2];
+        let __v_7: G = __r_arr[3];
+        let __v_8: G = __r_arr[4];
+        let __v_9: G = __r_arr[5];
+        let __v_10: G = __r_arr[6];
+        let __v_11: G = __r_arr[7];
+        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_3, __v_1]; 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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_3, __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 __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__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[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_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_15: G = __r_arr[0];
-        let __ret: [G; OUT_159] = [__v_15];
+        let __ret: [G; OUT_159] = [__v_14];
         record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -14870,7 +14763,7 @@ fn aiur_fn_160(
   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_203] = { let __args: [G; IN_203] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -14900,49 +14793,35 @@ fn aiur_fn_161(
 ) -> Result<[G; OUT_161], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(0);
-    let __v_2: G = G::from_u64(109);
-    let __v_3: G = G::from_u64(0);
-    let __v_4: G = G::from_u64(117);
-    let __v_5: G = G::from_u64(0);
-    let __v_6: G = G::from_u64(108);
-    let __v_7: G = G::from_u64(0);
+    let __v_1: G = G::from_u64(109);
+    let __v_2: G = G::from_u64(117);
+    let __v_3: G = G::from_u64(108);
+    let __v_4: G = G::from_u64(116);
+    let __v_5: G = G::from_u64(105);
+    let __v_6: G = G::from_u64(45);
+    let __v_7: G = G::from_u64(115);
     let __v_8: G = G::from_u64(116);
-    let __v_9: G = G::from_u64(0);
-    let __v_10: G = G::from_u64(105);
-    let __v_11: G = G::from_u64(0);
-    let __v_12: G = G::from_u64(45);
-    let __v_13: G = G::from_u64(0);
-    let __v_14: G = G::from_u64(115);
-    let __v_15: G = G::from_u64(0);
-    let __v_16: G = G::from_u64(116);
-    let __v_17: G = G::from_u64(0);
-    let __v_18: G = G::from_u64(97);
-    let __v_19: G = G::from_u64(0);
-    let __v_20: G = G::from_u64(114);
-    let __v_21: G = G::from_u64(0);
-    let __v_22: G = G::from_u64(107);
-    let __v_23: G = G::from_u64(0);
-    let __v_24: G = G::from_u64(47);
-    let __v_25: G = G::from_u64(0);
-    let __v_26: G = G::from_u64(118);
-    let __v_27: G = G::from_u64(0);
-    let __v_28: G = G::from_u64(48);
-    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_161] = [__v_42];
+    let __v_9: G = G::from_u64(97);
+    let __v_10: G = G::from_u64(114);
+    let __v_11: G = G::from_u64(107);
+    let __v_12: G = G::from_u64(47);
+    let __v_13: G = G::from_u64(118);
+    let __v_14: G = G::from_u64(48);
+    let __v_15: G = { let __values: [G; 2] = [__v_14, __v_0]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_16: G = { let __values: [G; 2] = [__v_13, __v_15]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_17: G = { let __values: [G; 2] = [__v_12, __v_16]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_18: G = { let __values: [G; 2] = [__v_11, __v_17]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_19: G = { let __values: [G; 2] = [__v_10, __v_18]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_20: G = { let __values: [G; 2] = [__v_9, __v_19]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_21: G = { let __values: [G; 2] = [__v_8, __v_20]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_22: G = { let __values: [G; 2] = [__v_7, __v_21]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_23: G = { let __values: [G; 2] = [__v_6, __v_22]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_24: G = { let __values: [G; 2] = [__v_5, __v_23]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_25: G = { let __values: [G; 2] = [__v_4, __v_24]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_26: G = { let __values: [G; 2] = [__v_3, __v_25]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_27: G = { let __values: [G; 2] = [__v_2, __v_26]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_28: G = { let __values: [G; 2] = [__v_1, __v_27]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_161] = [__v_28];
     record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -14962,10 +14841,8 @@ fn aiur_fn_162(
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_162] = [__v_4];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_162] = [__v_2];
         record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -15000,299 +14877,287 @@ fn aiur_fn_163(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __v_9: G = G::from_u64(1);
-    let __v_10: G = G::from_u64(1);
-    let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_7, __v_11]; 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_9: G = G::from_u64(0);
+    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_7, __v_9]; 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_10: G = __r_arr[0];
+    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_6, __v_10]; 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_11: G = __r_arr[0];
+    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_3, __v_11]; 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_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_6, __v_12]; 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_147] = { let __args: [G; IN_147] = [__v_2, __v_12]; 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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_13]; 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_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_2, __v_14]; 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_158] = { let __args: [G; IN_158] = [__v_0, __v_14]; 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_15]; 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_161] = { let __args: [G; IN_161] = [__v_15]; 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_16: G = __r_arr[0];
-    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_0, __v_16]; 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_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_17]; 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_17: G = G::from_u64(0);
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_16, __v_17]; 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_18: G = __r_arr[0];
-    let __v_19: G = G::from_u64(1);
-    let __v_20: G = G::from_u64(1);
-    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_18, __v_21]; 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_22: G = __r_arr[0];
-    let __v_23: G = __r_arr[1];
-    let __v_24: G = __r_arr[2];
-    let __v_25: G = __r_arr[3];
-    let __v_26: G = __r_arr[4];
-    let __v_27: G = __r_arr[5];
-    let __v_28: G = __r_arr[6];
-    let __v_29: G = __r_arr[7];
-    let __v_30: G = __r_arr[8];
-    let __v_31: G = __r_arr[9];
-    let __v_32: G = __r_arr[10];
-    let __v_33: G = __r_arr[11];
-    let __v_34: G = __r_arr[12];
-    let __v_35: G = __r_arr[13];
-    let __v_36: G = __r_arr[14];
-    let __v_37: G = __r_arr[15];
-    let __v_38: G = __r_arr[16];
-    let __v_39: G = __r_arr[17];
-    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_38, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_40: G = __r_arr[0];
-    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_40, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_41: G = __r_arr[0];
-    let __v_42: G = G::from_u64(1);
-    let __v_43: G = G::from_u64(1);
-    let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_41, __v_44]; 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_45: G = __r_arr[0];
-    let __v_46: G = __r_arr[1];
-    let __v_47: G = __r_arr[2];
-    let __v_48: G = __r_arr[3];
-    let __v_49: G = __r_arr[4];
-    let __v_50: G = __r_arr[5];
-    let __v_51: G = __r_arr[6];
-    let __v_52: G = __r_arr[7];
-    let __v_53: G = __r_arr[8];
-    let __v_54: G = __r_arr[9];
-    let __v_55: G = __r_arr[10];
-    let __v_56: G = __r_arr[11];
-    let __v_57: G = __r_arr[12];
-    let __v_58: G = __r_arr[13];
-    let __v_59: G = __r_arr[14];
-    let __v_60: G = __r_arr[15];
-    let __v_61: G = __r_arr[16];
-    let __v_62: G = __r_arr[17];
-    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_61, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_63: G = __r_arr[0];
-    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_63, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_19: G = __r_arr[1];
+    let __v_20: G = __r_arr[2];
+    let __v_21: G = __r_arr[3];
+    let __v_22: G = __r_arr[4];
+    let __v_23: G = __r_arr[5];
+    let __v_24: G = __r_arr[6];
+    let __v_25: G = __r_arr[7];
+    let __v_26: G = __r_arr[8];
+    let __v_27: G = __r_arr[9];
+    let __v_28: G = __r_arr[10];
+    let __v_29: G = __r_arr[11];
+    let __v_30: G = __r_arr[12];
+    let __v_31: G = __r_arr[13];
+    let __v_32: G = __r_arr[14];
+    let __v_33: G = __r_arr[15];
+    let __v_34: G = __r_arr[16];
+    let __v_35: G = __r_arr[17];
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_34, __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[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_36: G = __r_arr[0];
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_36, __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[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_37: G = __r_arr[0];
+    let __v_38: G = G::from_u64(0);
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_37, __v_38]; 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_39: G = __r_arr[0];
+    let __v_40: G = __r_arr[1];
+    let __v_41: G = __r_arr[2];
+    let __v_42: G = __r_arr[3];
+    let __v_43: G = __r_arr[4];
+    let __v_44: G = __r_arr[5];
+    let __v_45: G = __r_arr[6];
+    let __v_46: G = __r_arr[7];
+    let __v_47: G = __r_arr[8];
+    let __v_48: G = __r_arr[9];
+    let __v_49: G = __r_arr[10];
+    let __v_50: G = __r_arr[11];
+    let __v_51: G = __r_arr[12];
+    let __v_52: G = __r_arr[13];
+    let __v_53: G = __r_arr[14];
+    let __v_54: G = __r_arr[15];
+    let __v_55: G = __r_arr[16];
+    let __v_56: G = __r_arr[17];
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_55, __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[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_57: G = __r_arr[0];
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_57, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
+    let __v_58: G = __r_arr[0];
+    let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_58, __v_4]; 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_59: G = __r_arr[0];
+    let __v_60: G = G::from_u64(0);
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8, __v_60]; 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_61: G = __r_arr[0];
+    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_59, __v_61]; 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_62: G = __r_arr[0];
+    let __v_63: G = G::from_u64(0);
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_62, __v_63]; 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_64: G = __r_arr[0];
-    let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_64, __v_4]; 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_65: G = __r_arr[0];
-    let __v_66: G = G::from_u64(1);
-    let __v_67: G = G::from_u64(1);
-    let __v_68: G = { let __values: [G; 3] = [__v_66, __v_67, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8, __v_68]; 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_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_65, __v_69]; 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_70: G = __r_arr[0];
-    let __v_71: G = G::from_u64(1);
-    let __v_72: G = G::from_u64(1);
-    let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_70, __v_73]; 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_74: G = __r_arr[0];
-    let __v_75: G = __r_arr[1];
-    let __v_76: G = __r_arr[2];
-    let __v_77: G = __r_arr[3];
-    let __v_78: G = __r_arr[4];
-    let __v_79: G = __r_arr[5];
-    let __v_80: G = __r_arr[6];
-    let __v_81: G = __r_arr[7];
-    let __v_82: G = __r_arr[8];
-    let __v_83: G = __r_arr[9];
-    let __v_84: G = __r_arr[10];
-    let __v_85: G = __r_arr[11];
-    let __v_86: G = __r_arr[12];
-    let __v_87: G = __r_arr[13];
-    let __v_88: G = __r_arr[14];
-    let __v_89: G = __r_arr[15];
-    let __v_90: G = __r_arr[16];
-    let __v_91: G = __r_arr[17];
-    let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_90, __v_5]; 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_92: G = __r_arr[0];
-    let __v_93: G = G::from_u64(1);
-    let __v_94: G = G::from_u64(1);
-    let __v_95: G = { let __values: [G; 3] = [__v_93, __v_94, __v_94]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_92, __v_95]; 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_96: G = __r_arr[0];
-    let __v_97: G = __r_arr[1];
-    let __v_98: G = __r_arr[2];
-    let __v_99: G = __r_arr[3];
-    let __v_100: G = __r_arr[4];
-    let __v_101: G = __r_arr[5];
-    let __v_102: G = __r_arr[6];
-    let __v_103: G = __r_arr[7];
-    let __v_104: G = __r_arr[8];
-    let __v_105: G = __r_arr[9];
-    let __v_106: G = __r_arr[10];
-    let __v_107: G = __r_arr[11];
-    let __v_108: G = __r_arr[12];
-    let __v_109: G = __r_arr[13];
-    let __v_110: G = __r_arr[14];
-    let __v_111: G = __r_arr[15];
-    let __v_112: G = __r_arr[16];
-    let __v_113: G = __r_arr[17];
-    let __v_114: G = G::from_u64(256);
-    let __v_115: G = (__v_114 * __v_23);
-    let __v_116: G = G::from_u64(65536);
-    let __v_117: G = (__v_116 * __v_24);
-    let __v_118: G = G::from_u64(16777216);
-    let __v_119: G = (__v_118 * __v_25);
-    let __v_120: G = G::from_u64(4294967296);
-    let __v_121: G = (__v_120 * __v_26);
-    let __v_122: G = G::from_u64(1099511627776);
-    let __v_123: G = (__v_122 * __v_27);
-    let __v_124: G = G::from_u64(281474976710656);
-    let __v_125: G = (__v_124 * __v_28);
-    let __v_126: G = G::from_u64(72057594037927936);
-    let __v_127: G = (__v_126 * __v_29);
-    let __v_128: G = (__v_125 + __v_127);
-    let __v_129: G = (__v_123 + __v_128);
-    let __v_130: G = (__v_121 + __v_129);
-    let __v_131: G = (__v_119 + __v_130);
-    let __v_132: G = (__v_117 + __v_131);
-    let __v_133: G = (__v_115 + __v_132);
-    let __v_134: G = (__v_22 + __v_133);
-    let __v_135: G = G::from_u64(256);
-    let __v_136: G = (__v_135 * __v_31);
-    let __v_137: G = G::from_u64(65536);
-    let __v_138: G = (__v_137 * __v_32);
-    let __v_139: G = G::from_u64(16777216);
-    let __v_140: G = (__v_139 * __v_33);
-    let __v_141: G = G::from_u64(4294967296);
-    let __v_142: G = (__v_141 * __v_34);
-    let __v_143: G = G::from_u64(1099511627776);
-    let __v_144: G = (__v_143 * __v_35);
-    let __v_145: G = G::from_u64(281474976710656);
-    let __v_146: G = (__v_145 * __v_36);
-    let __v_147: G = G::from_u64(72057594037927936);
-    let __v_148: G = (__v_147 * __v_37);
-    let __v_149: G = (__v_146 + __v_148);
-    let __v_150: G = (__v_144 + __v_149);
-    let __v_151: G = (__v_142 + __v_150);
-    let __v_152: G = (__v_140 + __v_151);
-    let __v_153: G = (__v_138 + __v_152);
-    let __v_154: G = (__v_136 + __v_153);
-    let __v_155: G = (__v_30 + __v_154);
-    let __v_156: G = G::from_u64(256);
+    let __v_65: G = __r_arr[1];
+    let __v_66: G = __r_arr[2];
+    let __v_67: G = __r_arr[3];
+    let __v_68: G = __r_arr[4];
+    let __v_69: G = __r_arr[5];
+    let __v_70: G = __r_arr[6];
+    let __v_71: G = __r_arr[7];
+    let __v_72: G = __r_arr[8];
+    let __v_73: G = __r_arr[9];
+    let __v_74: G = __r_arr[10];
+    let __v_75: G = __r_arr[11];
+    let __v_76: G = __r_arr[12];
+    let __v_77: G = __r_arr[13];
+    let __v_78: G = __r_arr[14];
+    let __v_79: G = __r_arr[15];
+    let __v_80: G = __r_arr[16];
+    let __v_81: G = __r_arr[17];
+    let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_80, __v_5]; 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_82: G = __r_arr[0];
+    let __v_83: G = G::from_u64(0);
+    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_82, __v_83]; 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_84: G = __r_arr[0];
+    let __v_85: G = __r_arr[1];
+    let __v_86: G = __r_arr[2];
+    let __v_87: G = __r_arr[3];
+    let __v_88: G = __r_arr[4];
+    let __v_89: G = __r_arr[5];
+    let __v_90: G = __r_arr[6];
+    let __v_91: G = __r_arr[7];
+    let __v_92: G = __r_arr[8];
+    let __v_93: G = __r_arr[9];
+    let __v_94: G = __r_arr[10];
+    let __v_95: G = __r_arr[11];
+    let __v_96: G = __r_arr[12];
+    let __v_97: G = __r_arr[13];
+    let __v_98: G = __r_arr[14];
+    let __v_99: G = __r_arr[15];
+    let __v_100: G = __r_arr[16];
+    let __v_101: G = __r_arr[17];
+    let __v_102: G = G::from_u64(256);
+    let __v_103: G = (__v_102 * __v_19);
+    let __v_104: G = G::from_u64(65536);
+    let __v_105: G = (__v_104 * __v_20);
+    let __v_106: G = G::from_u64(16777216);
+    let __v_107: G = (__v_106 * __v_21);
+    let __v_108: G = G::from_u64(4294967296);
+    let __v_109: G = (__v_108 * __v_22);
+    let __v_110: G = G::from_u64(1099511627776);
+    let __v_111: G = (__v_110 * __v_23);
+    let __v_112: G = G::from_u64(281474976710656);
+    let __v_113: G = (__v_112 * __v_24);
+    let __v_114: G = G::from_u64(72057594037927936);
+    let __v_115: G = (__v_114 * __v_25);
+    let __v_116: G = (__v_113 + __v_115);
+    let __v_117: G = (__v_111 + __v_116);
+    let __v_118: G = (__v_109 + __v_117);
+    let __v_119: G = (__v_107 + __v_118);
+    let __v_120: G = (__v_105 + __v_119);
+    let __v_121: G = (__v_103 + __v_120);
+    let __v_122: G = (__v_18 + __v_121);
+    let __v_123: G = G::from_u64(256);
+    let __v_124: G = (__v_123 * __v_27);
+    let __v_125: G = G::from_u64(65536);
+    let __v_126: G = (__v_125 * __v_28);
+    let __v_127: G = G::from_u64(16777216);
+    let __v_128: G = (__v_127 * __v_29);
+    let __v_129: G = G::from_u64(4294967296);
+    let __v_130: G = (__v_129 * __v_30);
+    let __v_131: G = G::from_u64(1099511627776);
+    let __v_132: G = (__v_131 * __v_31);
+    let __v_133: G = G::from_u64(281474976710656);
+    let __v_134: G = (__v_133 * __v_32);
+    let __v_135: G = G::from_u64(72057594037927936);
+    let __v_136: G = (__v_135 * __v_33);
+    let __v_137: G = (__v_134 + __v_136);
+    let __v_138: G = (__v_132 + __v_137);
+    let __v_139: G = (__v_130 + __v_138);
+    let __v_140: G = (__v_128 + __v_139);
+    let __v_141: G = (__v_126 + __v_140);
+    let __v_142: G = (__v_124 + __v_141);
+    let __v_143: G = (__v_26 + __v_142);
+    let __v_144: G = G::from_u64(256);
+    let __v_145: G = (__v_144 * __v_40);
+    let __v_146: G = G::from_u64(65536);
+    let __v_147: G = (__v_146 * __v_41);
+    let __v_148: G = G::from_u64(16777216);
+    let __v_149: G = (__v_148 * __v_42);
+    let __v_150: G = G::from_u64(4294967296);
+    let __v_151: G = (__v_150 * __v_43);
+    let __v_152: G = G::from_u64(1099511627776);
+    let __v_153: G = (__v_152 * __v_44);
+    let __v_154: G = G::from_u64(281474976710656);
+    let __v_155: G = (__v_154 * __v_45);
+    let __v_156: G = G::from_u64(72057594037927936);
     let __v_157: G = (__v_156 * __v_46);
-    let __v_158: G = G::from_u64(65536);
-    let __v_159: G = (__v_158 * __v_47);
-    let __v_160: G = G::from_u64(16777216);
-    let __v_161: G = (__v_160 * __v_48);
-    let __v_162: G = G::from_u64(4294967296);
-    let __v_163: G = (__v_162 * __v_49);
-    let __v_164: G = G::from_u64(1099511627776);
-    let __v_165: G = (__v_164 * __v_50);
-    let __v_166: G = G::from_u64(281474976710656);
-    let __v_167: G = (__v_166 * __v_51);
-    let __v_168: G = G::from_u64(72057594037927936);
-    let __v_169: G = (__v_168 * __v_52);
-    let __v_170: G = (__v_167 + __v_169);
-    let __v_171: G = (__v_165 + __v_170);
-    let __v_172: G = (__v_163 + __v_171);
-    let __v_173: G = (__v_161 + __v_172);
-    let __v_174: G = (__v_159 + __v_173);
-    let __v_175: G = (__v_157 + __v_174);
-    let __v_176: G = (__v_45 + __v_175);
-    let __v_177: G = G::from_u64(256);
+    let __v_158: G = (__v_155 + __v_157);
+    let __v_159: G = (__v_153 + __v_158);
+    let __v_160: G = (__v_151 + __v_159);
+    let __v_161: G = (__v_149 + __v_160);
+    let __v_162: G = (__v_147 + __v_161);
+    let __v_163: G = (__v_145 + __v_162);
+    let __v_164: G = (__v_39 + __v_163);
+    let __v_165: G = G::from_u64(256);
+    let __v_166: G = (__v_165 * __v_48);
+    let __v_167: G = G::from_u64(65536);
+    let __v_168: G = (__v_167 * __v_49);
+    let __v_169: G = G::from_u64(16777216);
+    let __v_170: G = (__v_169 * __v_50);
+    let __v_171: G = G::from_u64(4294967296);
+    let __v_172: G = (__v_171 * __v_51);
+    let __v_173: G = G::from_u64(1099511627776);
+    let __v_174: G = (__v_173 * __v_52);
+    let __v_175: G = G::from_u64(281474976710656);
+    let __v_176: G = (__v_175 * __v_53);
+    let __v_177: G = G::from_u64(72057594037927936);
     let __v_178: G = (__v_177 * __v_54);
-    let __v_179: G = G::from_u64(65536);
-    let __v_180: G = (__v_179 * __v_55);
-    let __v_181: G = G::from_u64(16777216);
-    let __v_182: G = (__v_181 * __v_56);
-    let __v_183: G = G::from_u64(4294967296);
-    let __v_184: G = (__v_183 * __v_57);
-    let __v_185: G = G::from_u64(1099511627776);
-    let __v_186: G = (__v_185 * __v_58);
-    let __v_187: G = G::from_u64(281474976710656);
-    let __v_188: G = (__v_187 * __v_59);
-    let __v_189: G = G::from_u64(72057594037927936);
-    let __v_190: G = (__v_189 * __v_60);
-    let __v_191: G = (__v_188 + __v_190);
-    let __v_192: G = (__v_186 + __v_191);
-    let __v_193: G = (__v_184 + __v_192);
-    let __v_194: G = (__v_182 + __v_193);
-    let __v_195: G = (__v_180 + __v_194);
-    let __v_196: G = (__v_178 + __v_195);
-    let __v_197: G = (__v_53 + __v_196);
-    let __v_198: G = G::from_u64(256);
-    let __v_199: G = (__v_198 * __v_75);
-    let __v_200: G = G::from_u64(65536);
-    let __v_201: G = (__v_200 * __v_76);
-    let __v_202: G = G::from_u64(16777216);
-    let __v_203: G = (__v_202 * __v_77);
-    let __v_204: G = G::from_u64(4294967296);
-    let __v_205: G = (__v_204 * __v_78);
-    let __v_206: G = G::from_u64(1099511627776);
-    let __v_207: G = (__v_206 * __v_79);
-    let __v_208: G = G::from_u64(281474976710656);
-    let __v_209: G = (__v_208 * __v_80);
-    let __v_210: G = G::from_u64(72057594037927936);
-    let __v_211: G = (__v_210 * __v_81);
-    let __v_212: G = (__v_209 + __v_211);
-    let __v_213: G = (__v_207 + __v_212);
-    let __v_214: G = (__v_205 + __v_213);
-    let __v_215: G = (__v_203 + __v_214);
-    let __v_216: G = (__v_201 + __v_215);
-    let __v_217: G = (__v_199 + __v_216);
-    let __v_218: G = (__v_74 + __v_217);
-    let __v_219: G = G::from_u64(256);
-    let __v_220: G = (__v_219 * __v_83);
-    let __v_221: G = G::from_u64(65536);
-    let __v_222: G = (__v_221 * __v_84);
-    let __v_223: G = G::from_u64(16777216);
-    let __v_224: G = (__v_223 * __v_85);
-    let __v_225: G = G::from_u64(4294967296);
-    let __v_226: G = (__v_225 * __v_86);
-    let __v_227: G = G::from_u64(1099511627776);
-    let __v_228: G = (__v_227 * __v_87);
-    let __v_229: G = G::from_u64(281474976710656);
-    let __v_230: G = (__v_229 * __v_88);
-    let __v_231: G = G::from_u64(72057594037927936);
-    let __v_232: G = (__v_231 * __v_89);
-    let __v_233: G = (__v_230 + __v_232);
-    let __v_234: G = (__v_228 + __v_233);
-    let __v_235: G = (__v_226 + __v_234);
-    let __v_236: G = (__v_224 + __v_235);
-    let __v_237: G = (__v_222 + __v_236);
-    let __v_238: G = (__v_220 + __v_237);
-    let __v_239: G = (__v_82 + __v_238);
-    let __v_240: G = G::from_u64(256);
-    let __v_241: G = (__v_240 * __v_97);
-    let __v_242: G = G::from_u64(65536);
-    let __v_243: G = (__v_242 * __v_98);
-    let __v_244: G = G::from_u64(16777216);
-    let __v_245: G = (__v_244 * __v_99);
-    let __v_246: G = G::from_u64(4294967296);
-    let __v_247: G = (__v_246 * __v_100);
-    let __v_248: G = G::from_u64(1099511627776);
-    let __v_249: G = (__v_248 * __v_101);
-    let __v_250: G = G::from_u64(281474976710656);
-    let __v_251: G = (__v_250 * __v_102);
-    let __v_252: G = G::from_u64(72057594037927936);
-    let __v_253: G = (__v_252 * __v_103);
-    let __v_254: G = (__v_251 + __v_253);
-    let __v_255: G = (__v_249 + __v_254);
-    let __v_256: G = (__v_247 + __v_255);
-    let __v_257: G = (__v_245 + __v_256);
-    let __v_258: G = (__v_243 + __v_257);
-    let __v_259: G = (__v_241 + __v_258);
-    let __v_260: G = (__v_96 + __v_259);
-    let __v_261: G = G::from_u64(256);
-    let __v_262: G = (__v_261 * __v_105);
-    let __v_263: G = G::from_u64(65536);
-    let __v_264: G = (__v_263 * __v_106);
-    let __v_265: G = G::from_u64(16777216);
-    let __v_266: G = (__v_265 * __v_107);
-    let __v_267: G = G::from_u64(4294967296);
-    let __v_268: G = (__v_267 * __v_108);
-    let __v_269: G = G::from_u64(1099511627776);
-    let __v_270: G = (__v_269 * __v_109);
-    let __v_271: G = G::from_u64(281474976710656);
-    let __v_272: G = (__v_271 * __v_110);
-    let __v_273: G = G::from_u64(72057594037927936);
-    let __v_274: G = (__v_273 * __v_111);
-    let __v_275: G = (__v_272 + __v_274);
-    let __v_276: G = (__v_270 + __v_275);
-    let __v_277: G = (__v_268 + __v_276);
-    let __v_278: G = (__v_266 + __v_277);
-    let __v_279: G = (__v_264 + __v_278);
-    let __v_280: G = (__v_262 + __v_279);
-    let __v_281: G = (__v_104 + __v_280);
-    let __ret: [G; OUT_163] = [__v_134, __v_155, __v_176, __v_197, __v_218, __v_239, __v_260, __v_281, __v_112];
+    let __v_179: G = (__v_176 + __v_178);
+    let __v_180: G = (__v_174 + __v_179);
+    let __v_181: G = (__v_172 + __v_180);
+    let __v_182: G = (__v_170 + __v_181);
+    let __v_183: G = (__v_168 + __v_182);
+    let __v_184: G = (__v_166 + __v_183);
+    let __v_185: G = (__v_47 + __v_184);
+    let __v_186: G = G::from_u64(256);
+    let __v_187: G = (__v_186 * __v_65);
+    let __v_188: G = G::from_u64(65536);
+    let __v_189: G = (__v_188 * __v_66);
+    let __v_190: G = G::from_u64(16777216);
+    let __v_191: G = (__v_190 * __v_67);
+    let __v_192: G = G::from_u64(4294967296);
+    let __v_193: G = (__v_192 * __v_68);
+    let __v_194: G = G::from_u64(1099511627776);
+    let __v_195: G = (__v_194 * __v_69);
+    let __v_196: G = G::from_u64(281474976710656);
+    let __v_197: G = (__v_196 * __v_70);
+    let __v_198: G = G::from_u64(72057594037927936);
+    let __v_199: G = (__v_198 * __v_71);
+    let __v_200: G = (__v_197 + __v_199);
+    let __v_201: G = (__v_195 + __v_200);
+    let __v_202: G = (__v_193 + __v_201);
+    let __v_203: G = (__v_191 + __v_202);
+    let __v_204: G = (__v_189 + __v_203);
+    let __v_205: G = (__v_187 + __v_204);
+    let __v_206: G = (__v_64 + __v_205);
+    let __v_207: G = G::from_u64(256);
+    let __v_208: G = (__v_207 * __v_73);
+    let __v_209: G = G::from_u64(65536);
+    let __v_210: G = (__v_209 * __v_74);
+    let __v_211: G = G::from_u64(16777216);
+    let __v_212: G = (__v_211 * __v_75);
+    let __v_213: G = G::from_u64(4294967296);
+    let __v_214: G = (__v_213 * __v_76);
+    let __v_215: G = G::from_u64(1099511627776);
+    let __v_216: G = (__v_215 * __v_77);
+    let __v_217: G = G::from_u64(281474976710656);
+    let __v_218: G = (__v_217 * __v_78);
+    let __v_219: G = G::from_u64(72057594037927936);
+    let __v_220: G = (__v_219 * __v_79);
+    let __v_221: G = (__v_218 + __v_220);
+    let __v_222: G = (__v_216 + __v_221);
+    let __v_223: G = (__v_214 + __v_222);
+    let __v_224: G = (__v_212 + __v_223);
+    let __v_225: G = (__v_210 + __v_224);
+    let __v_226: G = (__v_208 + __v_225);
+    let __v_227: G = (__v_72 + __v_226);
+    let __v_228: G = G::from_u64(256);
+    let __v_229: G = (__v_228 * __v_85);
+    let __v_230: G = G::from_u64(65536);
+    let __v_231: G = (__v_230 * __v_86);
+    let __v_232: G = G::from_u64(16777216);
+    let __v_233: G = (__v_232 * __v_87);
+    let __v_234: G = G::from_u64(4294967296);
+    let __v_235: G = (__v_234 * __v_88);
+    let __v_236: G = G::from_u64(1099511627776);
+    let __v_237: G = (__v_236 * __v_89);
+    let __v_238: G = G::from_u64(281474976710656);
+    let __v_239: G = (__v_238 * __v_90);
+    let __v_240: G = G::from_u64(72057594037927936);
+    let __v_241: G = (__v_240 * __v_91);
+    let __v_242: G = (__v_239 + __v_241);
+    let __v_243: G = (__v_237 + __v_242);
+    let __v_244: G = (__v_235 + __v_243);
+    let __v_245: G = (__v_233 + __v_244);
+    let __v_246: G = (__v_231 + __v_245);
+    let __v_247: G = (__v_229 + __v_246);
+    let __v_248: G = (__v_84 + __v_247);
+    let __v_249: G = G::from_u64(256);
+    let __v_250: G = (__v_249 * __v_93);
+    let __v_251: G = G::from_u64(65536);
+    let __v_252: G = (__v_251 * __v_94);
+    let __v_253: G = G::from_u64(16777216);
+    let __v_254: G = (__v_253 * __v_95);
+    let __v_255: G = G::from_u64(4294967296);
+    let __v_256: G = (__v_255 * __v_96);
+    let __v_257: G = G::from_u64(1099511627776);
+    let __v_258: G = (__v_257 * __v_97);
+    let __v_259: G = G::from_u64(281474976710656);
+    let __v_260: G = (__v_259 * __v_98);
+    let __v_261: G = G::from_u64(72057594037927936);
+    let __v_262: G = (__v_261 * __v_99);
+    let __v_263: G = (__v_260 + __v_262);
+    let __v_264: G = (__v_258 + __v_263);
+    let __v_265: G = (__v_256 + __v_264);
+    let __v_266: G = (__v_254 + __v_265);
+    let __v_267: G = (__v_252 + __v_266);
+    let __v_268: G = (__v_250 + __v_267);
+    let __v_269: G = (__v_92 + __v_268);
+    let __ret: [G; OUT_163] = [__v_122, __v_143, __v_164, __v_185, __v_206, __v_227, __v_248, __v_269, __v_100];
     record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -15787,17 +15652,17 @@ fn aiur_fn_169(
         if (__v_24 != __v_25) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_21]; 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_203] = { let __args: [G; IN_203] = [__v_21]; 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_26: G = __r_arr[0];
         if (__v_26 != __v_23) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_22]; 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_203] = { let __args: [G; IN_203] = [__v_22]; 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_27: G = __r_arr[0];
         if (__v_27 != __v_23) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_18]; 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_203] = { let __args: [G; IN_203] = [__v_18]; 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_28: G = __r_arr[0];
         if (__v_28 != __v_23) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
@@ -15892,47 +15757,46 @@ fn aiur_fn_172(
 ) -> Result<[G; OUT_172], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_172] = [__v_7];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_172] = [__v_1];
         record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        let __v_8: G = __loaded[3];
-        match __v_5.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        match __v_3.as_canonical_u64() {
           0u64 => {
-            let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_2, __v_3, __v_6, __v_7]; 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_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_8]; 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_12: G = __r_arr[0];
-            let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_172] = [__v_13];
+            let __v_4: G = G::from_u64(0);
+            let __v_5: G = G::from_u64(1);
+            if (__v_4 != __v_5) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_172] = [__v_4];
             record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_4: G = __loaded[0];
+            let __v_5: G = __loaded[1];
+            let __v_6: G = __loaded[2];
+            let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __v_8: G = __r_arr[1];
+            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_6]; 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_9: G = __r_arr[0];
+            let __v_10: G = { let __values: [G; 3] = [__v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __ret: [G; OUT_172] = [__v_10];
+            record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -16144,33 +16008,29 @@ fn aiur_fn_174(
     let __v_16: G = inp[16];
     let __v_17: G = inp[17];
     let __v_18: G = inp[18];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_19: G = __loaded[0];
-    let __v_20: G = __loaded[1];
-    let __v_21: G = __loaded[2];
-    match __v_19.as_canonical_u64() {
-      1u64 => {
+    match __v_4.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_174] = [__v_0, __v_1];
         record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
-        let __v_22: G = __r_arr[0];
-        let __v_23: G = __r_arr[1];
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; 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_24: G = __r_arr[0];
-        let __v_25: G = __r_arr[1];
-        let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __v_27: G = __r_arr[1];
-        let __ret: [G; OUT_174] = [__v_26, __v_27];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_19: G = __loaded[0];
+        let __v_20: G = __loaded[1];
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_5, __v_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = __r_arr[0];
+        let __v_22: G = __r_arr[1];
+        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        let __v_24: G = __r_arr[1];
+        let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_23, __v_24, __v_2, __v_3, __v_20, __v_5, __v_6, __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[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_25: G = __r_arr[0];
+        let __v_26: G = __r_arr[1];
+        let __ret: [G; OUT_174] = [__v_25, __v_26];
         record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
-      },
     }
   })
 }
@@ -16274,42 +16134,38 @@ fn aiur_fn_176(
     let __v_16: G = inp[16];
     let __v_17: G = inp[17];
     let __v_18: G = inp[18];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_19: G = __loaded[0];
-    let __v_20: G = __loaded[1];
-    let __v_21: G = __loaded[2];
-    match __v_19.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_19: G = G::from_u64(0);
+        let __v_20: G = G::from_u64(0);
+        let __v_21: G = G::from_u64(0);
         let __v_22: G = G::from_u64(0);
-        let __v_23: G = G::from_u64(0);
-        let __v_24: G = G::from_u64(0);
-        let __v_25: G = G::from_u64(0);
-        let __ret: [G; OUT_176] = [__v_22, __v_23, __v_24, __v_25];
+        let __ret: [G; OUT_176] = [__v_19, __v_20, __v_21, __v_22];
         record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_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_175] = { let __args: [G; IN_175] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_26: G = __r_arr[0];
-        let __v_27: G = __r_arr[1];
-        let __v_28: G = __r_arr[2];
-        let __v_29: G = __r_arr[3];
-        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_30: G = __r_arr[0];
-        let __v_31: G = __r_arr[1];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_19: G = __loaded[0];
+        let __v_20: G = __loaded[1];
+        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_20, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[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_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 __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_21, __v_22, __v_23, __v_24, __v_1, __v_2, __v_3, __v_4]; 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_25: G = __r_arr[0];
+        let __v_26: G = __r_arr[1];
+        let __v_27: G = __r_arr[2];
+        let __v_28: G = __r_arr[3];
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_5, __v_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]; 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_29: G = __r_arr[0];
+        let __v_30: G = __r_arr[1];
+        let __v_31: G = (__v_25 + __v_29);
         let __v_32: G = (__v_26 + __v_30);
-        let __v_33: G = (__v_27 + __v_31);
-        let __ret: [G; OUT_176] = [__v_32, __v_33, __v_28, __v_29];
+        let __ret: [G; OUT_176] = [__v_31, __v_32, __v_27, __v_28];
         record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+        return Ok(__ret);
       },
     }
   })
@@ -16369,186 +16225,185 @@ fn aiur_fn_177(
     let __v_41: G = inp[41];
     let __v_42: G = inp[42];
     let __v_43: G = inp[43];
-    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_44: G = __loaded[0];
-    let __v_45: G = __loaded[1];
-    let __v_46: G = __loaded[2];
-    let __v_47: G = __loaded[3];
-    match __v_44.as_canonical_u64() {
-      1u64 => {
+    match __v_4.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_177] = [__v_0, __v_1];
         record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_45.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_44: G = __loaded[0];
+        let __v_45: G = __loaded[1];
+        let __v_46: G = __loaded[2];
+        match __v_44.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_48: G = __r_arr[0];
-            let __v_49: G = __r_arr[1];
-            let __v_50: G = __r_arr[2];
-            let __v_51: G = __r_arr[3];
-            let __v_52: G = (__v_48 + __v_22);
-            let __v_53: G = (__v_49 + __v_23);
-            let __v_54: G = (__v_50 + __v_24);
-            let __v_55: G = (__v_51 + __v_25);
-            let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_56: G = __r_arr[0];
-            let __v_57: G = __r_arr[1];
-            let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_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 = (__v_56 * __v_10);
-            let __v_63: G = G::from_u64(7);
-            let __v_64: G = (__v_57 * __v_11);
-            let __v_65: G = (__v_63 * __v_64);
-            let __v_66: G = (__v_62 + __v_65);
-            let __v_67: G = (__v_56 * __v_11);
-            let __v_68: G = (__v_57 * __v_10);
-            let __v_69: G = (__v_67 + __v_68);
-            let __v_70: G = (__v_58 + __v_66);
-            let __v_71: G = (__v_59 + __v_69);
-            let __v_72: G = (__v_56 * __v_12);
-            let __v_73: G = G::from_u64(7);
-            let __v_74: G = (__v_57 * __v_13);
-            let __v_75: G = (__v_73 * __v_74);
-            let __v_76: G = (__v_72 + __v_75);
-            let __v_77: G = (__v_56 * __v_13);
-            let __v_78: G = (__v_57 * __v_12);
-            let __v_79: G = (__v_77 + __v_78);
-            let __v_80: G = (__v_60 + __v_76);
-            let __v_81: G = (__v_61 + __v_79);
-            let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_82: G = __r_arr[0];
-            let __v_83: G = __r_arr[1];
-            let __v_84: G = __r_arr[2];
-            let __v_85: G = __r_arr[3];
-            let __v_86: G = G::from_u64(1);
-            let __v_87: G = (__v_86 - __v_6);
-            let __v_88: G = (__v_5 + __v_87);
-            match __v_88.as_canonical_u64() {
+            let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_45, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } };
+            let __v_47: G = __r_arr[0];
+            let __v_48: G = __r_arr[1];
+            let __v_49: G = __r_arr[2];
+            let __v_50: G = __r_arr[3];
+            let __v_51: G = (__v_47 + __v_22);
+            let __v_52: G = (__v_48 + __v_23);
+            let __v_53: G = (__v_49 + __v_24);
+            let __v_54: G = (__v_50 + __v_25);
+            let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_30, __v_44, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !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_55: G = __r_arr[0];
+            let __v_56: G = __r_arr[1];
+            let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_14, __v_15, __v_16, __v_17, __v_51, __v_52, __v_53, __v_54]; 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_57: G = __r_arr[0];
+            let __v_58: G = __r_arr[1];
+            let __v_59: G = __r_arr[2];
+            let __v_60: G = __r_arr[3];
+            let __v_61: G = (__v_55 * __v_10);
+            let __v_62: G = G::from_u64(7);
+            let __v_63: G = (__v_56 * __v_11);
+            let __v_64: G = (__v_62 * __v_63);
+            let __v_65: G = (__v_61 + __v_64);
+            let __v_66: G = (__v_55 * __v_11);
+            let __v_67: G = (__v_56 * __v_10);
+            let __v_68: G = (__v_66 + __v_67);
+            let __v_69: G = (__v_57 + __v_65);
+            let __v_70: G = (__v_58 + __v_68);
+            let __v_71: G = (__v_55 * __v_12);
+            let __v_72: G = G::from_u64(7);
+            let __v_73: G = (__v_56 * __v_13);
+            let __v_74: G = (__v_72 * __v_73);
+            let __v_75: G = (__v_71 + __v_74);
+            let __v_76: G = (__v_55 * __v_13);
+            let __v_77: G = (__v_56 * __v_12);
+            let __v_78: G = (__v_76 + __v_77);
+            let __v_79: G = (__v_59 + __v_75);
+            let __v_80: G = (__v_60 + __v_78);
+            let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_10, __v_11, __v_12, __v_13, __v_51, __v_52, __v_53, __v_54]; 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_81: G = __r_arr[0];
+            let __v_82: G = __r_arr[1];
+            let __v_83: G = __r_arr[2];
+            let __v_84: G = __r_arr[3];
+            let __v_85: G = G::from_u64(1);
+            let __v_86: G = (__v_85 - __v_6);
+            let __v_87: G = (__v_5 + __v_86);
+            match __v_87.as_canonical_u64() {
               0u64 => {
-                let __v_89: G = (__v_7 + __v_7);
-                let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_35, __v_89]; 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_90: G = __r_arr[0];
-                let __v_91: G = __r_arr[1];
-                let __v_92: G = G::from_u64(1);
+                let __v_88: G = (__v_7 + __v_7);
+                let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_35, __v_88]; 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_89: G = __r_arr[0];
+                let __v_90: G = __r_arr[1];
+                let __v_91: G = G::from_u64(1);
+                let __v_92: G = (__v_7 + __v_91);
                 let __v_93: G = (__v_7 + __v_92);
-                let __v_94: G = (__v_7 + __v_93);
-                let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_35, __v_94]; 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_95: G = __r_arr[0];
-                let __v_96: G = __r_arr[1];
-                let __v_97: G = G::from_u64(0);
-                let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_36, __v_97]; 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_98: G = __r_arr[0];
-                let __v_99: G = __r_arr[1];
-                let __v_100: G = (__v_98 + __v_18);
-                let __v_101: G = (__v_99 + __v_19);
-                let __v_102: G = G::from_u64(1);
-                let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_36, __v_102]; 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_103: G = __r_arr[0];
-                let __v_104: G = __r_arr[1];
-                let __v_105: G = (__v_103 + __v_20);
-                let __v_106: G = (__v_104 + __v_21);
+                let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_35, __v_93]; 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_94: G = __r_arr[0];
+                let __v_95: G = __r_arr[1];
+                let __v_96: G = G::from_u64(0);
+                let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_36, __v_96]; 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_97: G = __r_arr[0];
+                let __v_98: G = __r_arr[1];
+                let __v_99: G = (__v_97 + __v_18);
+                let __v_100: G = (__v_98 + __v_19);
+                let __v_101: G = G::from_u64(1);
+                let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_36, __v_101]; 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_102: G = __r_arr[0];
+                let __v_103: G = __r_arr[1];
+                let __v_104: G = (__v_102 + __v_20);
+                let __v_105: G = (__v_103 + __v_21);
+                let __v_106: G = (__v_99 - __v_89);
                 let __v_107: G = (__v_100 - __v_90);
-                let __v_108: G = (__v_101 - __v_91);
+                let __v_108: G = (__v_104 - __v_94);
                 let __v_109: G = (__v_105 - __v_95);
-                let __v_110: G = (__v_106 - __v_96);
-                let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_111: G = __r_arr[0];
-                let __v_112: G = __r_arr[1];
-                let __v_113: G = __r_arr[2];
-                let __v_114: G = __r_arr[3];
+                let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_81, __v_82, __v_83, __v_84, __v_106, __v_107, __v_108, __v_109]; 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_110: G = __r_arr[0];
+                let __v_111: G = __r_arr[1];
+                let __v_112: G = __r_arr[2];
+                let __v_113: G = __r_arr[3];
+                let __v_114: G = (__v_110 - __v_69);
                 let __v_115: G = (__v_111 - __v_70);
-                let __v_116: G = (__v_112 - __v_71);
-                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; 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_117: G = __r_arr[0];
-                let __v_118: G = __r_arr[1];
+                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3, __v_114, __v_115]; 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_116: G = __r_arr[0];
+                let __v_117: G = __r_arr[1];
+                let __v_118: G = (__v_112 - __v_79);
                 let __v_119: G = (__v_113 - __v_80);
-                let __v_120: G = (__v_114 - __v_81);
-                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; 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_121: G = __r_arr[0];
-                let __v_122: G = __r_arr[1];
-                let __ret: [G; OUT_177] = [__v_121, __v_122];
+                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_116, __v_117, __v_2, __v_3, __v_118, __v_119]; 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_120: G = __r_arr[0];
+                let __v_121: G = __r_arr[1];
+                let __ret: [G; OUT_177] = [__v_120, __v_121];
                 record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_89: G = G::from_u64(1);
-                let __v_90: G = (__v_8 - __v_89);
-                match __v_90.as_canonical_u64() {
+                let __v_88: G = G::from_u64(1);
+                let __v_89: G = (__v_8 - __v_88);
+                match __v_89.as_canonical_u64() {
                   0u64 => {
-                    let __v_91: G = (__v_7 + __v_7);
-                    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_35, __v_91]; 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_92: G = __r_arr[0];
-                    let __v_93: G = __r_arr[1];
-                    let __v_94: G = G::from_u64(1);
+                    let __v_90: G = (__v_7 + __v_7);
+                    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_35, __v_90]; 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_91: G = __r_arr[0];
+                    let __v_92: G = __r_arr[1];
+                    let __v_93: G = G::from_u64(1);
+                    let __v_94: G = (__v_7 + __v_93);
                     let __v_95: G = (__v_7 + __v_94);
-                    let __v_96: G = (__v_7 + __v_95);
-                    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_35, __v_96]; 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_97: G = __r_arr[0];
-                    let __v_98: G = __r_arr[1];
-                    let __v_99: G = G::from_u64(2);
+                    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_35, __v_95]; 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_96: G = __r_arr[0];
+                    let __v_97: G = __r_arr[1];
+                    let __v_98: G = G::from_u64(2);
+                    let __v_99: G = (__v_7 + __v_98);
                     let __v_100: G = (__v_7 + __v_99);
-                    let __v_101: G = (__v_7 + __v_100);
-                    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_35, __v_101]; 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_102: G = __r_arr[0];
-                    let __v_103: G = __r_arr[1];
-                    let __v_104: G = G::from_u64(3);
+                    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_35, __v_100]; 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_101: G = __r_arr[0];
+                    let __v_102: G = __r_arr[1];
+                    let __v_103: G = G::from_u64(3);
+                    let __v_104: G = (__v_7 + __v_103);
                     let __v_105: G = (__v_7 + __v_104);
-                    let __v_106: G = (__v_7 + __v_105);
-                    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_35, __v_106]; 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_107: G = __r_arr[0];
-                    let __v_108: G = __r_arr[1];
+                    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_35, __v_105]; 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_106: G = __r_arr[0];
+                    let __v_107: G = __r_arr[1];
+                    let __v_108: G = (__v_101 - __v_91);
                     let __v_109: G = (__v_102 - __v_92);
-                    let __v_110: G = (__v_103 - __v_93);
+                    let __v_110: G = (__v_106 - __v_96);
                     let __v_111: G = (__v_107 - __v_97);
-                    let __v_112: G = (__v_108 - __v_98);
-                    let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_113: G = __r_arr[0];
-                    let __v_114: G = __r_arr[1];
-                    let __v_115: G = __r_arr[2];
-                    let __v_116: G = __r_arr[3];
+                    let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_81, __v_82, __v_83, __v_84, __v_108, __v_109, __v_110, __v_111]; 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_112: G = __r_arr[0];
+                    let __v_113: G = __r_arr[1];
+                    let __v_114: G = __r_arr[2];
+                    let __v_115: G = __r_arr[3];
+                    let __v_116: G = (__v_112 - __v_69);
                     let __v_117: G = (__v_113 - __v_70);
-                    let __v_118: G = (__v_114 - __v_71);
-                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; 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_119: G = __r_arr[0];
-                    let __v_120: G = __r_arr[1];
+                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3, __v_116, __v_117]; 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_118: G = __r_arr[0];
+                    let __v_119: G = __r_arr[1];
+                    let __v_120: G = (__v_114 - __v_79);
                     let __v_121: G = (__v_115 - __v_80);
-                    let __v_122: G = (__v_116 - __v_81);
-                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; 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_123: G = __r_arr[0];
-                    let __v_124: G = __r_arr[1];
-                    let __v_125: G = G::from_u64(1);
-                    let __v_126: G = (__v_5 + __v_125);
-                    let __v_127: G = G::from_u64(1);
-                    let __v_128: G = (__v_7 + __v_127);
-                    let __v_129: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_118, __v_119, __v_2, __v_3, __v_120, __v_121]; 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_122: G = __r_arr[0];
+                    let __v_123: G = __r_arr[1];
+                    let __v_124: G = G::from_u64(1);
+                    let __v_125: G = (__v_5 + __v_124);
+                    let __v_126: G = G::from_u64(1);
+                    let __v_127: G = (__v_7 + __v_126);
+                    let __v_128: G = G::from_u64(1);
+                    let __v_129: G = G::from_u64(0);
                     let __v_130: G = G::from_u64(0);
                     let __v_131: G = G::from_u64(0);
                     let __v_132: G = G::from_u64(0);
                     let __v_133: G = G::from_u64(0);
                     let __v_134: G = G::from_u64(0);
                     let __v_135: G = G::from_u64(0);
-                    let __v_136: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_137: G = __r_arr[0];
-                    let __v_138: G = __r_arr[1];
-                    let __ret: [G; OUT_177] = [__v_137, __v_138];
+                    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_122, __v_123, __v_2, __v_3, __v_46, __v_125, __v_6, __v_127, __v_9, __v_9, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_136: G = __r_arr[0];
+                    let __v_137: G = __r_arr[1];
+                    let __ret: [G; OUT_177] = [__v_136, __v_137];
                     record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __v_91: G = G::from_u64(1);
-                    let __v_92: G = (__v_5 + __v_91);
-                    let __v_93: G = G::from_u64(1);
-                    let __v_94: G = (__v_8 - __v_93);
-                    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_95: G = __r_arr[0];
-                    let __v_96: G = __r_arr[1];
-                    let __ret: [G; OUT_177] = [__v_95, __v_96];
+                    let __v_90: G = G::from_u64(1);
+                    let __v_91: G = (__v_5 + __v_90);
+                    let __v_92: G = G::from_u64(1);
+                    let __v_93: G = (__v_8 - __v_92);
+                    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2, __v_3, __v_46, __v_91, __v_6, __v_7, __v_93, __v_9, __v_81, __v_82, __v_83, __v_84, __v_69, __v_70, __v_79, __v_80, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_94: G = __r_arr[0];
+                    let __v_95: G = __r_arr[1];
+                    let __ret: [G; OUT_177] = [__v_94, __v_95];
                     record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
@@ -16558,9 +16413,6 @@ fn aiur_fn_177(
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64()));
-      },
     }
   })
 }
@@ -16670,70 +16522,66 @@ fn aiur_fn_178(
     let __v_83: G = (__v_13 * __v_77);
     let __v_84: G = (__v_14 * __v_74);
     let __v_85: G = (__v_83 + __v_84);
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_86: G = __loaded[0];
-    let __v_87: G = __loaded[1];
-    let __v_88: G = __loaded[2];
-    let __v_89: G = __loaded[3];
-    match __v_86.as_canonical_u64() {
-      1u64 => {
-        let __v_90: G = G::from_u64(0);
-        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_9, __v_90]; 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_91: G = __r_arr[0];
-        let __v_92: G = __r_arr[1];
-        let __v_93: G = G::from_u64(0);
-        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_8, __v_93]; 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_94: G = __r_arr[0];
-        let __v_95: G = __r_arr[1];
-        let __v_96: G = (__v_91 - __v_94);
-        let __v_97: G = (__v_92 - __v_95);
-        let __v_98: G = (__v_96 + __v_63);
-        let __v_99: G = (__v_97 + __v_66);
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_22, __v_23, __v_17, __v_18, __v_98, __v_99]; 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_100: G = __r_arr[0];
-        let __v_101: G = __r_arr[1];
-        let __v_102: G = G::from_u64(1);
-        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_9, __v_102]; 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_103: G = __r_arr[0];
-        let __v_104: G = __r_arr[1];
-        let __v_105: G = G::from_u64(1);
-        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_8, __v_105]; 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_106: G = __r_arr[0];
-        let __v_107: G = __r_arr[1];
-        let __v_108: G = (__v_103 - __v_106);
-        let __v_109: G = (__v_104 - __v_107);
-        let __v_110: G = (__v_108 + __v_82);
-        let __v_111: G = (__v_109 + __v_85);
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_100, __v_101, __v_17, __v_18, __v_110, __v_111]; 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_112: G = __r_arr[0];
-        let __v_113: G = __r_arr[1];
-        let __ret: [G; OUT_178] = [__v_112, __v_113];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_86: G = G::from_u64(0);
+        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_9, __v_86]; 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_87: G = __r_arr[0];
+        let __v_88: G = __r_arr[1];
+        let __v_89: G = G::from_u64(0);
+        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_8, __v_89]; 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_90: G = __r_arr[0];
+        let __v_91: G = __r_arr[1];
+        let __v_92: G = (__v_87 - __v_90);
+        let __v_93: G = (__v_88 - __v_91);
+        let __v_94: G = (__v_92 + __v_63);
+        let __v_95: G = (__v_93 + __v_66);
+        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_22, __v_23, __v_17, __v_18, __v_94, __v_95]; 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_96: G = __r_arr[0];
+        let __v_97: G = __r_arr[1];
+        let __v_98: G = G::from_u64(1);
+        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_9, __v_98]; 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_99: G = __r_arr[0];
+        let __v_100: G = __r_arr[1];
+        let __v_101: G = G::from_u64(1);
+        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_8, __v_101]; 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_102: G = __r_arr[0];
+        let __v_103: G = __r_arr[1];
+        let __v_104: G = (__v_99 - __v_102);
+        let __v_105: G = (__v_100 - __v_103);
+        let __v_106: G = (__v_104 + __v_82);
+        let __v_107: G = (__v_105 + __v_85);
+        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_96, __v_97, __v_17, __v_18, __v_106, __v_107]; 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_108: G = __r_arr[0];
+        let __v_109: G = __r_arr[1];
+        let __ret: [G; OUT_178] = [__v_108, __v_109];
         record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_90: G = G::from_u64(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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_86: G = __loaded[0];
+        let __v_87: G = __loaded[1];
+        let __v_88: G = __loaded[2];
+        let __v_89: G = G::from_u64(0);
         let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
-        let __v_91: G = __r_arr[0];
-        let __v_92: G = G::from_u64(0);
-        let __v_93: G = G::from_u64(1);
+        let __v_90: G = __r_arr[0];
+        let __v_91: G = G::from_u64(0);
+        let __v_92: G = G::from_u64(1);
+        let __v_93: G = G::from_u64(0);
         let __v_94: G = G::from_u64(0);
         let __v_95: G = G::from_u64(0);
         let __v_96: G = G::from_u64(0);
         let __v_97: G = G::from_u64(0);
         let __v_98: G = G::from_u64(0);
         let __v_99: G = G::from_u64(0);
-        let __v_100: G = G::from_u64(0);
-        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_22, __v_23, __v_17, __v_18, __v_2, __v_90, __v_91, __v_92, __v_3, __v_3, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_63, __v_66, __v_82, __v_85, __v_25, __v_26, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_0, __v_4, __v_5, __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[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_101: G = __r_arr[0];
-        let __v_102: G = __r_arr[1];
-        let __ret: [G; OUT_178] = [__v_101, __v_102];
+        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_22, __v_23, __v_17, __v_18, __v_2, __v_89, __v_90, __v_91, __v_3, __v_3, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_63, __v_66, __v_82, __v_85, __v_25, __v_26, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_0, __v_4, __v_5, __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[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_100: G = __r_arr[0];
+        let __v_101: G = __r_arr[1];
+        let __ret: [G; OUT_178] = [__v_100, __v_101];
         record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_86.as_canonical_u64()));
-      },
     }
   })
 }
@@ -16765,25 +16613,15 @@ fn aiur_fn_179(
     let __v_14: G = G::from_u64(0);
     let __v_15: G = G::from_u64(0);
     let __v_16: G = G::from_u64(0);
-    let __v_17: G = G::from_u64(0);
-    let __v_18: G = G::from_u64(0);
-    let __v_19: G = G::from_u64(0);
-    let __v_20: G = G::from_u64(0);
-    let __v_21: G = G::from_u64(0);
-    let __v_22: G = G::from_u64(0);
-    let __v_23: G = G::from_u64(0);
-    let __v_24: G = G::from_u64(1);
-    let __v_25: G = G::from_u64(1);
-    let __v_26: G = { let __values: [G; 4] = [__v_24, __v_25, __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 __v_27: G = { let __values: [G; 4] = [__v_22, __v_7, __v_23, __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 __values: [G; 4] = [__v_20, __v_6, __v_21, __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 = { let __values: [G; 4] = [__v_18, __v_5, __v_19, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_30: G = { let __values: [G; 4] = [__v_16, __v_4, __v_17, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_31: G = { let __values: [G; 4] = [__v_14, __v_3, __v_15, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_179] = [__v_34];
+    let __v_17: G = { let __values: [G; 3] = [__v_7, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_18: G = { let __values: [G; 3] = [__v_6, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_19: G = { let __values: [G; 3] = [__v_5, __v_13, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_20: G = { let __values: [G; 3] = [__v_4, __v_12, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_21: G = { let __values: [G; 3] = [__v_3, __v_11, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_22: G = { let __values: [G; 3] = [__v_2, __v_10, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_23: G = { let __values: [G; 3] = [__v_1, __v_9, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_24: G = { let __values: [G; 3] = [__v_0, __v_8, __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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_179] = [__v_24];
     record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
@@ -16804,47 +16642,43 @@ fn aiur_fn_180(
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    let __v_8: G = __loaded[3];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_180] = [__v_9, __v_10];
-        record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_9: G = (__v_3 * __v_6);
-        let __v_10: G = G::from_u64(7);
-        let __v_11: G = (__v_4 * __v_7);
-        let __v_12: G = (__v_10 * __v_11);
-        let __v_13: G = (__v_9 + __v_12);
-        let __v_14: G = (__v_3 * __v_7);
-        let __v_15: G = (__v_4 * __v_6);
-        let __v_16: G = (__v_14 + __v_15);
-        let __v_17: G = (__v_3 * __v_1);
-        let __v_18: G = G::from_u64(7);
-        let __v_19: G = (__v_4 * __v_2);
-        let __v_20: G = (__v_18 * __v_19);
-        let __v_21: G = (__v_17 + __v_20);
-        let __v_22: G = (__v_3 * __v_2);
-        let __v_23: G = (__v_4 * __v_1);
-        let __v_24: G = (__v_22 + __v_23);
-        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __v_26: G = __r_arr[1];
-        let __v_27: G = (__v_13 + __v_25);
-        let __v_28: G = (__v_16 + __v_26);
-        let __ret: [G; OUT_180] = [__v_27, __v_28];
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_180] = [__v_5, __v_6];
         record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = (__v_3 * __v_5);
+        let __v_9: G = G::from_u64(7);
+        let __v_10: G = (__v_4 * __v_6);
+        let __v_11: G = (__v_9 * __v_10);
+        let __v_12: G = (__v_8 + __v_11);
+        let __v_13: G = (__v_3 * __v_6);
+        let __v_14: G = (__v_4 * __v_5);
+        let __v_15: G = (__v_13 + __v_14);
+        let __v_16: G = (__v_3 * __v_1);
+        let __v_17: G = G::from_u64(7);
+        let __v_18: G = (__v_4 * __v_2);
+        let __v_19: G = (__v_17 * __v_18);
+        let __v_20: G = (__v_16 + __v_19);
+        let __v_21: G = (__v_3 * __v_2);
+        let __v_22: G = (__v_4 * __v_1);
+        let __v_23: G = (__v_21 + __v_22);
+        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_7, __v_1, __v_2, __v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __v_25: G = __r_arr[1];
+        let __v_26: G = (__v_12 + __v_24);
+        let __v_27: G = (__v_15 + __v_25);
+        let __ret: [G; OUT_180] = [__v_26, __v_27];
+        record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -16996,26 +16830,18 @@ fn aiur_fn_182(
     let __v_3: G = inp[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __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_182] = [__v_6, __v_9];
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_182] = [__v_4, __v_5];
         record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         match __v_0.as_canonical_u64() {
           0u64 => {
-            let __v_4: G = G::from_u64(1);
-            let __v_5: G = G::from_u64(1);
-            let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __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_182] = [__v_6, __v_9];
+            let __v_4: G = G::from_u64(0);
+            let __v_5: G = G::from_u64(0);
+            let __ret: [G; OUT_182] = [__v_4, __v_5];
             record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
@@ -17074,140 +16900,136 @@ fn aiur_fn_183(
     let __v_17: G = inp[17];
     let __v_18: G = inp[18];
     let __v_19: G = inp[19];
-    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-    let __v_20: G = __loaded[0];
-    let __v_21: G = __loaded[1];
-    let __v_22: G = __loaded[2];
-    let __v_23: G = __loaded[3];
-    let __v_24: G = __loaded[4];
-    let __v_25: G = __loaded[5];
-    let __v_26: G = __loaded[6];
-    let __v_27: G = __loaded[7];
-    match __v_20.as_canonical_u64() {
-      1u64 => {
-        let __v_28: G = G::from_u64(1);
-        let __ret: [G; OUT_183] = [__v_28];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_20: G = G::from_u64(1);
+        let __ret: [G; OUT_183] = [__v_20];
         record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_21.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+        let __v_20: G = __loaded[0];
+        let __v_21: G = __loaded[1];
+        let __v_22: G = __loaded[2];
+        let __v_23: G = __loaded[3];
+        let __v_24: G = __loaded[4];
+        let __v_25: G = __loaded[5];
+        let __v_26: G = __loaded[6];
+        match __v_20.as_canonical_u64() {
           _ => {
             let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+            let __v_27: G = __r_arr[0];
+            let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_23]; 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
-            let __v_29: G = __r_arr[0];
             let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_3, __v_9]; 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_30: G = __r_arr[0];
-            let __v_31: G = __r_arr[1];
+            let __v_29: G = __r_arr[0];
+            let __v_30: G = __r_arr[1];
             let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_4, __v_9]; 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_32: G = __r_arr[0];
-            let __v_33: G = G::from_u64(0);
-            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_32, __v_33]; 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_34: G = __r_arr[0];
-            let __v_35: G = G::from_u64(1);
-            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_32, __v_35]; 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_36: G = __r_arr[0];
+            let __v_31: G = __r_arr[0];
+            let __v_32: G = G::from_u64(0);
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+            let __v_33: G = __r_arr[0];
+            let __v_34: G = G::from_u64(1);
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_31, __v_34]; 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_35: G = __r_arr[0];
             let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_9]; 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_37: G = __r_arr[0];
-            let __v_38: G = G::from_u64(0);
-            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_37, __v_38]; 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_39: G = __r_arr[0];
-            let __v_40: G = G::from_u64(1);
-            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_37, __v_40]; 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_41: G = __r_arr[0];
+            let __v_36: G = __r_arr[0];
+            let __v_37: G = G::from_u64(0);
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+            let __v_38: G = __r_arr[0];
+            let __v_39: G = G::from_u64(1);
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_36, __v_39]; 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_40: G = __r_arr[0];
             let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_1, __v_9]; 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_42: G = __r_arr[0];
-            let __v_43: G = __r_arr[1];
-            let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_6, __v_7, __v_42, __v_43]; 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_44: G = __r_arr[0];
-            let __v_45: G = __r_arr[1];
-            let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_18, __v_19, __v_28]; 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_46: G = __r_arr[0];
-            let __v_47: G = __r_arr[1];
-            let __v_48: G = __r_arr[2];
-            let __v_49: G = __r_arr[3];
-            let __v_50: G = __r_arr[4];
-            let __v_51: G = __r_arr[5];
-            let __v_52: G = __r_arr[6];
-            let __v_53: G = __r_arr[7];
-            let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_12, __v_13, __v_14, __v_15, __v_10, __v_11, __v_30, __v_31]; 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_41: G = __r_arr[0];
+            let __v_42: G = __r_arr[1];
+            let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_6, __v_7, __v_41, __v_42]; 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_43: G = __r_arr[0];
+            let __v_44: G = __r_arr[1];
+            let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_18, __v_19, __v_27]; 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_45: G = __r_arr[0];
+            let __v_46: G = __r_arr[1];
+            let __v_47: G = __r_arr[2];
+            let __v_48: G = __r_arr[3];
+            let __v_49: G = __r_arr[4];
+            let __v_50: G = __r_arr[5];
+            let __v_51: G = __r_arr[6];
+            let __v_52: G = __r_arr[7];
+            let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_12, __v_13, __v_14, __v_15, __v_10, __v_11, __v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } else { aiur_fn_179(__args, record, io_buffer, __cu)? } };
+            let __v_53: G = __r_arr[0];
+            let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_27]; 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_54: G = __r_arr[0];
-            let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_28]; 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_165] = { let __args: [G; IN_165] = [__v_27]; 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_55: G = __r_arr[0];
-            let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_28]; 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_56: G = __r_arr[0];
-            let __v_57: G = (__v_55 * __v_56);
-            let __v_58: G = g_inverse_value(__v_57);
-            let __v_59: G = (__v_57 * __v_58);
-            let __v_60: G = G::from_u64(1);
-            let __v_61: G = (__v_59 - __v_60);
-            let __v_62: G = (__v_57 * __v_61);
-            let __v_63: G = G::from_u64(0);
-            if (__v_62 != __v_63) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_63.as_canonical_u64(), msg: None });
+            let __v_56: G = (__v_54 * __v_55);
+            let __v_57: G = g_inverse_value(__v_56);
+            let __v_58: G = (__v_56 * __v_57);
+            let __v_59: G = G::from_u64(1);
+            let __v_60: G = (__v_58 - __v_59);
+            let __v_61: G = (__v_56 * __v_60);
+            let __v_62: G = G::from_u64(0);
+            if (__v_61 != __v_62) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: None });
             }
-            let __v_64: G = (__v_58 * __v_61);
-            let __v_65: G = G::from_u64(0);
-            if (__v_64 != __v_65) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None });
+            let __v_63: G = (__v_57 * __v_60);
+            let __v_64: G = G::from_u64(0);
+            if (__v_63 != __v_64) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_64.as_canonical_u64(), msg: None });
             }
-            let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_21, __v_23, __v_25, __v_26, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_54, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_16, __v_17, __v_58]; 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_66: G = __r_arr[0];
-            let __v_67: G = __r_arr[1];
+            let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_20, __v_22, __v_24, __v_25, __v_33, __v_35, __v_43, __v_44, __v_38, __v_40, __v_53, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_16, __v_17, __v_57]; 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_65: G = __r_arr[0];
+            let __v_66: G = __r_arr[1];
             let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_8, __v_9]; 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_68: G = __r_arr[0];
-            let __v_69: G = G::from_u64(0);
-            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_68, __v_69]; 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_67: G = __r_arr[0];
+            let __v_68: G = G::from_u64(0);
+            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_67, __v_68]; 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_69: G = __r_arr[0];
+            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_69]; 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_70: G = __r_arr[0];
-            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_18, __v_19, __v_27]; 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_71: G = __r_arr[0];
-            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_18, __v_19, __v_28]; 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_72: G = __r_arr[0];
-            let __v_73: G = __r_arr[1];
-            let __v_74: G = G::from_u64(1);
-            let __v_75: G = G::from_u64(0);
-            let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
-            let __v_76: G = __r_arr[0];
-            let __v_77: G = __r_arr[1];
-            let __v_78: G = (__v_66 * __v_52);
-            let __v_79: G = G::from_u64(7);
-            let __v_80: G = (__v_67 * __v_53);
-            let __v_81: G = (__v_79 * __v_80);
-            let __v_82: G = (__v_78 + __v_81);
-            let __v_83: G = (__v_66 * __v_53);
-            let __v_84: G = (__v_67 * __v_52);
-            let __v_85: G = (__v_83 + __v_84);
-            let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_71]; 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_86: G = __r_arr[0];
-            let __v_87: G = (__v_86 - __v_29);
-            let __v_88: G = G::from_bool((__v_87 == G::ZERO));
-            let __v_89: G = G::from_u64(1);
-            if (__v_88 != __v_89) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_89.as_canonical_u64(), msg: None });
+            let __v_72: G = __r_arr[1];
+            let __v_73: G = G::from_u64(1);
+            let __v_74: G = G::from_u64(0);
+            let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
+            let __v_75: G = __r_arr[0];
+            let __v_76: G = __r_arr[1];
+            let __v_77: G = (__v_65 * __v_51);
+            let __v_78: G = G::from_u64(7);
+            let __v_79: G = (__v_66 * __v_52);
+            let __v_80: G = (__v_78 * __v_79);
+            let __v_81: G = (__v_77 + __v_80);
+            let __v_82: G = (__v_65 * __v_52);
+            let __v_83: G = (__v_66 * __v_51);
+            let __v_84: G = (__v_82 + __v_83);
+            let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_70]; 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_85: G = __r_arr[0];
+            let __v_86: G = (__v_85 - __v_28);
+            let __v_87: G = G::from_bool((__v_86 == G::ZERO));
+            let __v_88: G = G::from_u64(1);
+            if (__v_87 != __v_88) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None });
             }
-            let __v_90: G = (__v_82 - __v_76);
-            let __v_91: G = G::from_bool((__v_90 == G::ZERO));
-            let __v_92: G = (__v_85 - __v_77);
-            let __v_93: G = G::from_bool((__v_92 == G::ZERO));
-            let __v_94: G = (__v_91 * __v_93);
-            let __v_95: G = G::from_u64(1);
-            if (__v_94 != __v_95) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_95.as_canonical_u64(), msg: None });
+            let __v_89: G = (__v_81 - __v_75);
+            let __v_90: G = G::from_bool((__v_89 == G::ZERO));
+            let __v_91: G = (__v_84 - __v_76);
+            let __v_92: G = G::from_bool((__v_91 == G::ZERO));
+            let __v_93: G = (__v_90 * __v_92);
+            let __v_94: G = G::from_u64(1);
+            if (__v_93 != __v_94) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_94.as_canonical_u64(), msg: None });
             }
-            let __v_96: G = G::from_u64(1);
-            let __v_97: G = (__v_9 + __v_96);
-            let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_97, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_98: G = __r_arr[0];
-            let __ret: [G; OUT_183] = [__v_98];
+            let __v_95: G = G::from_u64(1);
+            let __v_96: G = (__v_9 + __v_95);
+            let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_26, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_96, __v_29, __v_30, __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[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_97: G = __r_arr[0];
+            let __ret: [G; OUT_183] = [__v_97];
             record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
-      },
     }
   })
 }
@@ -17225,67 +17047,63 @@ fn aiur_fn_184(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    let __v_9: G = __loaded[6];
-    let __v_10: G = __loaded[7];
-    let __v_11: G = __loaded[8];
-    let __v_12: G = __loaded[9];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_184] = [__v_13, __v_14];
-        record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_2.as_canonical_u64() {
       0u64 => {
-        let __v_13: G = G::from_u64(256);
-        let __v_14: G = (__v_13 * __v_5);
-        let __v_15: G = G::from_u64(65536);
-        let __v_16: G = (__v_15 * __v_6);
-        let __v_17: G = G::from_u64(16777216);
-        let __v_18: G = (__v_17 * __v_7);
-        let __v_19: G = G::from_u64(4294967296);
-        let __v_20: G = (__v_19 * __v_8);
-        let __v_21: G = G::from_u64(1099511627776);
-        let __v_22: G = (__v_21 * __v_9);
-        let __v_23: G = G::from_u64(281474976710656);
-        let __v_24: G = (__v_23 * __v_10);
-        let __v_25: G = G::from_u64(72057594037927936);
-        let __v_26: G = (__v_25 * __v_11);
-        let __v_27: G = (__v_24 + __v_26);
-        let __v_28: G = (__v_22 + __v_27);
-        let __v_29: G = (__v_20 + __v_28);
-        let __v_30: G = (__v_18 + __v_29);
-        let __v_31: G = (__v_16 + __v_30);
-        let __v_32: G = (__v_14 + __v_31);
-        let __v_33: G = (__v_4 + __v_32);
-        let __v_34: G = G::from_u64(0);
-        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_1, __v_12]; 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_35: G = __r_arr[0];
-        let __v_36: G = __r_arr[1];
-        let __v_37: G = (__v_0 * __v_35);
-        let __v_38: G = G::from_u64(7);
-        let __v_39: G = (__v_1 * __v_36);
-        let __v_40: G = (__v_38 * __v_39);
-        let __v_41: G = (__v_37 + __v_40);
-        let __v_42: G = (__v_0 * __v_36);
-        let __v_43: G = (__v_1 * __v_35);
-        let __v_44: G = (__v_42 + __v_43);
-        let __v_45: G = (__v_33 + __v_41);
-        let __v_46: G = (__v_34 + __v_44);
-        let __ret: [G; OUT_184] = [__v_45, __v_46];
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_184] = [__v_3, __v_4];
         record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        let __v_7: G = __loaded[4];
+        let __v_8: G = __loaded[5];
+        let __v_9: G = __loaded[6];
+        let __v_10: G = __loaded[7];
+        let __v_11: G = __loaded[8];
+        let __v_12: G = G::from_u64(256);
+        let __v_13: G = (__v_12 * __v_4);
+        let __v_14: G = G::from_u64(65536);
+        let __v_15: G = (__v_14 * __v_5);
+        let __v_16: G = G::from_u64(16777216);
+        let __v_17: G = (__v_16 * __v_6);
+        let __v_18: G = G::from_u64(4294967296);
+        let __v_19: G = (__v_18 * __v_7);
+        let __v_20: G = G::from_u64(1099511627776);
+        let __v_21: G = (__v_20 * __v_8);
+        let __v_22: G = G::from_u64(281474976710656);
+        let __v_23: G = (__v_22 * __v_9);
+        let __v_24: G = G::from_u64(72057594037927936);
+        let __v_25: G = (__v_24 * __v_10);
+        let __v_26: G = (__v_23 + __v_25);
+        let __v_27: G = (__v_21 + __v_26);
+        let __v_28: G = (__v_19 + __v_27);
+        let __v_29: G = (__v_17 + __v_28);
+        let __v_30: G = (__v_15 + __v_29);
+        let __v_31: G = (__v_13 + __v_30);
+        let __v_32: G = (__v_3 + __v_31);
+        let __v_33: G = G::from_u64(0);
+        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_1, __v_11]; 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_34: G = __r_arr[0];
+        let __v_35: G = __r_arr[1];
+        let __v_36: G = (__v_0 * __v_34);
+        let __v_37: G = G::from_u64(7);
+        let __v_38: G = (__v_1 * __v_35);
+        let __v_39: G = (__v_37 * __v_38);
+        let __v_40: G = (__v_36 + __v_39);
+        let __v_41: G = (__v_0 * __v_35);
+        let __v_42: G = (__v_1 * __v_34);
+        let __v_43: G = (__v_41 + __v_42);
+        let __v_44: G = (__v_32 + __v_40);
+        let __v_45: G = (__v_33 + __v_43);
+        let __ret: [G; OUT_184] = [__v_44, __v_45];
+        record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -17308,57 +17126,53 @@ fn aiur_fn_185(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_7: G = __loaded[0];
-    let __v_8: G = __loaded[1];
-    let __v_9: G = __loaded[2];
-    match __v_7.as_canonical_u64() {
-      1u64 => {
+    match __v_2.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_185] = [__v_0, __v_1];
         record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_5, __v_6, __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 __v_11: G = __r_arr[1];
-        let __v_12: G = (__v_3 + __v_10);
-        let __v_13: G = (__v_4 + __v_11);
-        let __v_14: G = (__v_12 * __v_12);
-        let __v_15: G = G::from_u64(7);
-        let __v_16: G = (__v_13 * __v_13);
-        let __v_17: G = (__v_15 * __v_16);
-        let __v_18: G = (__v_14 - __v_17);
-        let __v_19: G = g_inverse_value(__v_18);
-        let __v_20: G = (__v_18 * __v_19);
-        let __v_21: G = G::from_u64(1);
-        let __v_22: G = (__v_20 - __v_21);
-        let __v_23: G = (__v_18 * __v_22);
-        let __v_24: G = G::from_u64(0);
-        if (__v_23 != __v_24) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __v_10: G = __r_arr[1];
+        let __v_11: G = (__v_3 + __v_9);
+        let __v_12: G = (__v_4 + __v_10);
+        let __v_13: G = (__v_11 * __v_11);
+        let __v_14: G = G::from_u64(7);
+        let __v_15: G = (__v_12 * __v_12);
+        let __v_16: G = (__v_14 * __v_15);
+        let __v_17: G = (__v_13 - __v_16);
+        let __v_18: G = g_inverse_value(__v_17);
+        let __v_19: G = (__v_17 * __v_18);
+        let __v_20: G = G::from_u64(1);
+        let __v_21: G = (__v_19 - __v_20);
+        let __v_22: G = (__v_17 * __v_21);
+        let __v_23: G = G::from_u64(0);
+        if (__v_22 != __v_23) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
         }
-        let __v_25: G = (__v_19 * __v_22);
-        let __v_26: G = G::from_u64(0);
-        if (__v_25 != __v_26) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: None });
+        let __v_24: G = (__v_18 * __v_21);
+        let __v_25: G = G::from_u64(0);
+        if (__v_24 != __v_25) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None });
         }
-        let __v_27: G = (__v_12 * __v_19);
-        let __v_28: G = G::from_u64(0);
-        let __v_29: G = (__v_28 - __v_13);
-        let __v_30: G = (__v_29 * __v_19);
-        let __v_31: G = (__v_0 + __v_27);
-        let __v_32: G = (__v_1 + __v_30);
-        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; 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_33: G = __r_arr[0];
-        let __v_34: G = __r_arr[1];
-        let __ret: [G; OUT_185] = [__v_33, __v_34];
+        let __v_26: G = (__v_11 * __v_18);
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = (__v_27 - __v_12);
+        let __v_29: G = (__v_28 * __v_18);
+        let __v_30: G = (__v_0 + __v_26);
+        let __v_31: G = (__v_1 + __v_29);
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_30, __v_31, __v_8, __v_3, __v_4, __v_5, __v_6]; 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_32: G = __r_arr[0];
+        let __v_33: G = __r_arr[1];
+        let __ret: [G; OUT_185] = [__v_32, __v_33];
         record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-      },
     }
   })
 }
@@ -17447,7 +17261,7 @@ fn aiur_fn_186(
                     if (__v_54 != __v_55) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_12]; 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_203] = { let __args: [G; IN_203] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
                     let __v_56: G = __r_arr[0];
                     let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !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_57: G = __r_arr[0];
@@ -17496,34 +17310,30 @@ fn aiur_fn_187(
 ) -> Result<[G; OUT_187], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_187] = [__v_4];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_187] = [__v_1];
         record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = (__v_2 - __v_4);
-        let __v_6: G = (__v_2 * __v_5);
-        let __v_7: G = G::from_u64(0);
-        if (__v_6 != __v_7) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None });
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = (__v_1 - __v_3);
+        let __v_5: G = (__v_1 * __v_4);
+        let __v_6: G = G::from_u64(0);
+        if (__v_5 != __v_6) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None });
         }
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_187] = [__v_8];
+        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_187] = [__v_7];
         record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -17540,58 +17350,57 @@ fn aiur_fn_188(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_188] = [__v_12];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_188] = [__v_2];
         record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_10: G = __loaded[0];
-        let __v_11: G = __loaded[1];
-        let __v_12: G = __loaded[2];
-        match __v_10.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            match __v_11.as_canonical_u64() {
+            let __v_9: G = G::from_u64(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(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_188] = [__v_9];
+            record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_9: G = __loaded[0];
+            let __v_10: G = __loaded[1];
+            match __v_9.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
-                let __v_13: G = __r_arr[0];
-                let __ret: [G; OUT_188] = [__v_13];
+                let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                let __ret: [G; OUT_188] = [__v_11];
                 record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_13: G = G::from_u64(0);
-                let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
-                let __v_14: G = __r_arr[0];
-                let __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_188] = [__v_15];
+                let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                let __v_12: G = { let __values: [G; 7] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_188] = [__v_12];
                 record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -17608,54 +17417,53 @@ fn aiur_fn_189(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_189] = [__v_8];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_189] = [__v_2];
         record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            match __v_7.as_canonical_u64() {
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
+            if (__v_5 != __v_6) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_189] = [__v_5];
+            record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_5: G = __loaded[0];
+            let __v_6: G = __loaded[1];
+            match __v_5.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-                let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_189] = [__v_9];
+                let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
+                let __v_7: G = __r_arr[0];
+                let __ret: [G; OUT_189] = [__v_7];
                 record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_9: G = G::from_u64(0);
-                let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-                let __v_10: G = __r_arr[0];
-                let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_189] = [__v_11];
+                let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
+                let __v_7: G = __r_arr[0];
+                let __v_8: G = { let __values: [G; 3] = [__v_2, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __ret: [G; OUT_189] = [__v_8];
                 record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -17697,10 +17505,8 @@ fn aiur_fn_191(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_191] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_191] = [__v_2, __v_0];
         record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -17713,9 +17519,8 @@ fn aiur_fn_191(
         let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_3, __v_5]; 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_191] = [__v_9, __v_7];
+        let __v_8: G = { let __values: [G; 2] = [__v_2, __v_6]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_191] = [__v_8, __v_7];
         record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -17760,10 +17565,8 @@ fn aiur_fn_193(
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_193] = [__v_4, __v_0];
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_193] = [__v_2, __v_0];
         record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -17783,9 +17586,8 @@ fn aiur_fn_193(
         let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_10, __v_12]; 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_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __v_15: G = G::from_u64(0);
-        let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_193] = [__v_16, __v_14];
+        let __v_15: G = { let __values: [G; 9] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_193] = [__v_15, __v_14];
         record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
@@ -18096,209 +17898,187 @@ fn aiur_fn_194(
     if (__v_183 != __v_31) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_183.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
     }
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_110.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_184: G = __loaded[0];
-    let __v_185: G = __loaded[1];
-    let __v_186: G = __loaded[2];
-    let __v_187: G = G::from_u64(1);
-    let __v_188: G = G::from_u64(1);
-    if (__v_184 != __v_187) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: None });
-    }
-    if (__v_185 != __v_188) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_185.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: None });
-    }
-    if (__v_186 != __v_188) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: None });
+    let __v_184: G = G::from_u64(0);
+    if (__v_110 != __v_184) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_110.as_canonical_u64(), rhs: __v_184.as_canonical_u64(), msg: None });
     }
     let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_116]; 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_189: G = __r_arr[0];
-    let __v_190: G = __r_arr[1];
-    let __v_191: G = __r_arr[2];
-    let __v_192: G = __r_arr[3];
-    let __v_193: G = __r_arr[4];
-    let __v_194: G = __r_arr[5];
-    let __v_195: G = __r_arr[6];
-    let __v_196: G = __r_arr[7];
-    let __v_197: G = __r_arr[8];
-    let __v_198: G = __r_arr[9];
-    let __v_199: G = __r_arr[10];
-    let __v_200: G = __r_arr[11];
-    let __v_201: G = __r_arr[12];
-    let __v_202: G = __r_arr[13];
-    let __v_203: G = __r_arr[14];
-    let __v_204: G = __r_arr[15];
-    let __v_205: G = __r_arr[16];
-    let __v_206: G = __r_arr[17];
-    let __v_207: G = __r_arr[18];
-    let __v_208: G = __r_arr[19];
-    let __v_209: G = __r_arr[20];
-    let __v_210: G = __r_arr[21];
-    let __v_211: G = __r_arr[22];
-    let __v_212: G = __r_arr[23];
-    let __v_213: G = __r_arr[24];
-    let __v_214: G = __r_arr[25];
-    let __v_215: G = __r_arr[26];
-    let __v_216: G = __r_arr[27];
-    let __v_217: G = __r_arr[28];
-    let __v_218: G = __r_arr[29];
-    let __v_219: G = __r_arr[30];
-    let __v_220: G = __r_arr[31];
-    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220]; 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_221: G = __r_arr[0];
-    let __v_222: G = __r_arr[1];
-    let __v_223: G = __r_arr[2];
-    let __v_224: G = __r_arr[3];
-    let __v_225: G = __r_arr[4];
-    let __v_226: G = __r_arr[5];
-    let __v_227: G = __r_arr[6];
-    let __v_228: G = __r_arr[7];
-    let __v_229: G = __r_arr[8];
-    let __v_230: G = __r_arr[9];
-    let __v_231: G = __r_arr[10];
-    let __v_232: G = __r_arr[11];
-    let __v_233: G = __r_arr[12];
-    let __v_234: G = __r_arr[13];
-    let __v_235: G = __r_arr[14];
-    let __v_236: G = __r_arr[15];
-    let __v_237: G = __r_arr[16];
-    let __v_238: G = __r_arr[17];
-    let __v_239: G = __r_arr[18];
-    let __v_240: G = __r_arr[19];
-    let __v_241: G = __r_arr[20];
-    let __v_242: G = __r_arr[21];
-    let __v_243: G = __r_arr[22];
-    let __v_244: G = __r_arr[23];
-    let __v_245: G = __r_arr[24];
-    let __v_246: G = __r_arr[25];
-    let __v_247: G = __r_arr[26];
-    let __v_248: G = __r_arr[27];
-    let __v_249: G = __r_arr[28];
-    let __v_250: G = __r_arr[29];
-    let __v_251: G = __r_arr[30];
-    let __v_252: G = __r_arr[31];
-    if (__v_221 != __v_32) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_221.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
-    }
-    if (__v_222 != __v_33) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_222.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None });
+    let __v_185: G = __r_arr[0];
+    let __v_186: G = __r_arr[1];
+    let __v_187: G = __r_arr[2];
+    let __v_188: G = __r_arr[3];
+    let __v_189: G = __r_arr[4];
+    let __v_190: G = __r_arr[5];
+    let __v_191: G = __r_arr[6];
+    let __v_192: G = __r_arr[7];
+    let __v_193: G = __r_arr[8];
+    let __v_194: G = __r_arr[9];
+    let __v_195: G = __r_arr[10];
+    let __v_196: G = __r_arr[11];
+    let __v_197: G = __r_arr[12];
+    let __v_198: G = __r_arr[13];
+    let __v_199: G = __r_arr[14];
+    let __v_200: G = __r_arr[15];
+    let __v_201: G = __r_arr[16];
+    let __v_202: G = __r_arr[17];
+    let __v_203: G = __r_arr[18];
+    let __v_204: G = __r_arr[19];
+    let __v_205: G = __r_arr[20];
+    let __v_206: G = __r_arr[21];
+    let __v_207: G = __r_arr[22];
+    let __v_208: G = __r_arr[23];
+    let __v_209: G = __r_arr[24];
+    let __v_210: G = __r_arr[25];
+    let __v_211: G = __r_arr[26];
+    let __v_212: G = __r_arr[27];
+    let __v_213: G = __r_arr[28];
+    let __v_214: G = __r_arr[29];
+    let __v_215: G = __r_arr[30];
+    let __v_216: G = __r_arr[31];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216]; 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_217: G = __r_arr[0];
+    let __v_218: G = __r_arr[1];
+    let __v_219: G = __r_arr[2];
+    let __v_220: G = __r_arr[3];
+    let __v_221: G = __r_arr[4];
+    let __v_222: G = __r_arr[5];
+    let __v_223: G = __r_arr[6];
+    let __v_224: G = __r_arr[7];
+    let __v_225: G = __r_arr[8];
+    let __v_226: G = __r_arr[9];
+    let __v_227: G = __r_arr[10];
+    let __v_228: G = __r_arr[11];
+    let __v_229: G = __r_arr[12];
+    let __v_230: G = __r_arr[13];
+    let __v_231: G = __r_arr[14];
+    let __v_232: G = __r_arr[15];
+    let __v_233: G = __r_arr[16];
+    let __v_234: G = __r_arr[17];
+    let __v_235: G = __r_arr[18];
+    let __v_236: G = __r_arr[19];
+    let __v_237: G = __r_arr[20];
+    let __v_238: G = __r_arr[21];
+    let __v_239: G = __r_arr[22];
+    let __v_240: G = __r_arr[23];
+    let __v_241: G = __r_arr[24];
+    let __v_242: G = __r_arr[25];
+    let __v_243: G = __r_arr[26];
+    let __v_244: G = __r_arr[27];
+    let __v_245: G = __r_arr[28];
+    let __v_246: G = __r_arr[29];
+    let __v_247: G = __r_arr[30];
+    let __v_248: G = __r_arr[31];
+    if (__v_217 != __v_32) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
     }
-    if (__v_223 != __v_34) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_223.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: None });
+    if (__v_218 != __v_33) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_218.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None });
     }
-    if (__v_224 != __v_35) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_224.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: None });
+    if (__v_219 != __v_34) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_219.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: None });
     }
-    if (__v_225 != __v_36) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_225.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None });
+    if (__v_220 != __v_35) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_220.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: None });
     }
-    if (__v_226 != __v_37) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_226.as_canonical_u64(), rhs: __v_37.as_canonical_u64(), msg: None });
+    if (__v_221 != __v_36) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_221.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None });
     }
-    if (__v_227 != __v_38) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_227.as_canonical_u64(), rhs: __v_38.as_canonical_u64(), msg: None });
+    if (__v_222 != __v_37) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_222.as_canonical_u64(), rhs: __v_37.as_canonical_u64(), msg: None });
     }
-    if (__v_228 != __v_39) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_228.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: None });
+    if (__v_223 != __v_38) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_223.as_canonical_u64(), rhs: __v_38.as_canonical_u64(), msg: None });
     }
-    if (__v_229 != __v_40) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_229.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None });
+    if (__v_224 != __v_39) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_224.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: None });
     }
-    if (__v_230 != __v_41) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_230.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None });
+    if (__v_225 != __v_40) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_225.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None });
     }
-    if (__v_231 != __v_42) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_231.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None });
+    if (__v_226 != __v_41) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_226.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None });
     }
-    if (__v_232 != __v_43) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_232.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None });
+    if (__v_227 != __v_42) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_227.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None });
     }
-    if (__v_233 != __v_44) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_233.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None });
+    if (__v_228 != __v_43) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_228.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None });
     }
-    if (__v_234 != __v_45) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_234.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None });
+    if (__v_229 != __v_44) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_229.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None });
     }
-    if (__v_235 != __v_46) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_235.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None });
+    if (__v_230 != __v_45) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_230.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None });
     }
-    if (__v_236 != __v_47) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: None });
+    if (__v_231 != __v_46) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_231.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None });
     }
-    if (__v_237 != __v_48) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_237.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None });
+    if (__v_232 != __v_47) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_232.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: None });
     }
-    if (__v_238 != __v_49) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_238.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: None });
+    if (__v_233 != __v_48) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_233.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None });
     }
-    if (__v_239 != __v_50) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_239.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: None });
+    if (__v_234 != __v_49) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_234.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: None });
     }
-    if (__v_240 != __v_51) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None });
+    if (__v_235 != __v_50) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_235.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: None });
     }
-    if (__v_241 != __v_52) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None });
+    if (__v_236 != __v_51) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None });
     }
-    if (__v_242 != __v_53) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: None });
+    if (__v_237 != __v_52) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_237.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None });
     }
-    if (__v_243 != __v_54) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_243.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None });
+    if (__v_238 != __v_53) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_238.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: None });
     }
-    if (__v_244 != __v_55) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_244.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None });
+    if (__v_239 != __v_54) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_239.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None });
     }
-    if (__v_245 != __v_56) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_245.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: None });
+    if (__v_240 != __v_55) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None });
     }
-    if (__v_246 != __v_57) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_246.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: None });
+    if (__v_241 != __v_56) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: None });
     }
-    if (__v_247 != __v_58) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_247.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None });
+    if (__v_242 != __v_57) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: None });
     }
-    if (__v_248 != __v_59) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_248.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None });
+    if (__v_243 != __v_58) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_243.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None });
     }
-    if (__v_249 != __v_60) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_249.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
+    if (__v_244 != __v_59) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_244.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None });
     }
-    if (__v_250 != __v_61) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_250.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None });
+    if (__v_245 != __v_60) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_245.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
     }
-    if (__v_251 != __v_62) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: None });
+    if (__v_246 != __v_61) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_246.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None });
     }
-    if (__v_252 != __v_63) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_63.as_canonical_u64(), msg: None });
+    if (__v_247 != __v_62) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_247.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: None });
     }
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_118.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_253: G = __loaded[0];
-    let __v_254: G = __loaded[1];
-    let __v_255: G = __loaded[2];
-    let __v_256: G = G::from_u64(1);
-    let __v_257: G = G::from_u64(1);
-    if (__v_253 != __v_256) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_253.as_canonical_u64(), rhs: __v_256.as_canonical_u64(), msg: None });
+    if (__v_248 != __v_63) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_248.as_canonical_u64(), rhs: __v_63.as_canonical_u64(), msg: None });
     }
-    if (__v_254 != __v_257) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_254.as_canonical_u64(), rhs: __v_257.as_canonical_u64(), msg: None });
-    }
-    if (__v_255 != __v_257) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_257.as_canonical_u64(), msg: None });
+    let __v_249: G = G::from_u64(0);
+    if (__v_118 != __v_249) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_118.as_canonical_u64(), rhs: __v_249.as_canonical_u64(), msg: None });
     }
     let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[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_258: G = __r_arr[0];
-    let __v_259: G = G::from_u64(1);
-    if (__v_258 != __v_259) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_258.as_canonical_u64(), rhs: __v_259.as_canonical_u64(), msg: None });
+    let __v_250: G = __r_arr[0];
+    let __v_251: G = G::from_u64(1);
+    if (__v_250 != __v_251) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_250.as_canonical_u64(), rhs: __v_251.as_canonical_u64(), msg: None });
     }
     let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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_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_117]; 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_260: G = __r_arr[0];
-    let __v_261: G = G::from_u64(1);
-    if (__v_260 != __v_261) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_260.as_canonical_u64(), rhs: __v_261.as_canonical_u64(), msg: None });
+    let __v_252: G = __r_arr[0];
+    let __v_253: G = G::from_u64(1);
+    if (__v_252 != __v_253) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_253.as_canonical_u64(), msg: None });
     }
     let __ret: [G; OUT_194] = [];
     record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -18308,7 +18088,7 @@ fn aiur_fn_194(
 
 const INPUT_SIZE_195: usize = 1;
 const IN_195: usize = 1;
-const OUT_195: usize = 1;
+const OUT_195: usize = 8;
 fn aiur_fn_195(
   inp: [G; IN_195],
   record: &mut QueryRecord,
@@ -18317,29 +18097,46 @@ fn aiur_fn_195(
 ) -> Result<[G; OUT_195], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(0);
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_195] = [__v_4];
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_195] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
         record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_3]; 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_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_195] = [__v_6];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !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];
+        let __v_5: G = __r_arr[2];
+        let __v_6: G = __r_arr[3];
+        let __v_7: G = __r_arr[4];
+        let __v_8: G = __r_arr[5];
+        let __v_9: G = __r_arr[6];
+        let __v_10: G = __r_arr[7];
+        let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__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[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = __r_arr[1];
+        let __v_13: G = __r_arr[2];
+        let __v_14: G = __r_arr[3];
+        let __v_15: G = __r_arr[4];
+        let __v_16: G = __r_arr[5];
+        let __v_17: G = __r_arr[6];
+        let __v_18: G = __r_arr[7];
+        let __ret: [G; OUT_195] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
         record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
@@ -18355,25 +18152,18 @@ fn aiur_fn_196(
 ) -> 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 };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_196] = [__v_4];
-        record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_196] = [__v_4];
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_196] = [__v_1];
         record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_196] = [__v_1];
+        record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -18393,19 +18183,25 @@ fn aiur_fn_197(
     let __v_1: G = inp[1];
     let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0, __v_1]; 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_2: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    match __v_3.as_canonical_u64() {
+    match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_197] = [__v_4, __v_5];
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(1);
+        if (__v_3 != __v_4) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_197] = [__v_3, __v_3];
         record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __ret: [G; OUT_197] = [__v_3, __v_4];
+        record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -18422,56 +18218,52 @@ fn aiur_fn_198(
 ) -> Result<[G; OUT_198], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = G::from_u64(0);
-        let __v_16: G = G::from_u64(0);
-        let __v_17: G = G::from_u64(0);
-        let __v_18: G = G::from_u64(0);
-        let __ret: [G; OUT_198] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
-        record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        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 __v_11: G = __r_arr[0];
-        let __v_12: G = __r_arr[1];
-        let __v_13: G = __r_arr[2];
-        let __v_14: G = __r_arr[3];
-        let __v_15: G = __r_arr[4];
-        let __v_16: G = __r_arr[5];
-        let __v_17: G = __r_arr[6];
-        let __v_18: G = __r_arr[7];
-        let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __v_20: G = __r_arr[1];
-        let __v_21: G = __r_arr[2];
-        let __v_22: G = __r_arr[3];
-        let __v_23: G = __r_arr[4];
-        let __v_24: G = __r_arr[5];
-        let __v_25: G = __r_arr[6];
-        let __v_26: G = __r_arr[7];
-        let __ret: [G; OUT_198] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
+        let __v_1: G = G::from_u64(0);
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_198] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
         record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        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 __v_10: G = __r_arr[0];
+        let __v_11: G = __r_arr[1];
+        let __v_12: G = __r_arr[2];
+        let __v_13: G = __r_arr[3];
+        let __v_14: G = __r_arr[4];
+        let __v_15: G = __r_arr[5];
+        let __v_16: G = __r_arr[6];
+        let __v_17: G = __r_arr[7];
+        let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__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[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__args, record, io_buffer, __cu)? } };
+        let __v_18: G = __r_arr[0];
+        let __v_19: G = __r_arr[1];
+        let __v_20: G = __r_arr[2];
+        let __v_21: G = __r_arr[3];
+        let __v_22: G = __r_arr[4];
+        let __v_23: G = __r_arr[5];
+        let __v_24: G = __r_arr[6];
+        let __v_25: G = __r_arr[7];
+        let __ret: [G; OUT_198] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -18491,18 +18283,24 @@ fn aiur_fn_199(
     let __v_1: G = inp[1];
     let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !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_2: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
+    match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_199] = [__v_4];
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(1);
+        if (__v_3 != __v_4) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_199] = [__v_3];
         record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __ret: [G; OUT_199] = [__v_3];
+        record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -18519,30 +18317,26 @@ fn aiur_fn_200(
 ) -> Result<[G; OUT_200], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_200] = [__v_6];
-        record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        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_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_200] = [__v_8];
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_200] = [__v_1];
         record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __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 = G::from_u64(1);
+        let __v_7: G = (__v_5 + __v_6);
+        let __ret: [G; OUT_200] = [__v_7];
+        record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -18559,29 +18353,25 @@ fn aiur_fn_201(
 ) -> Result<[G; OUT_201], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_201] = [__v_5];
-        record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__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 = G::from_u64(1);
-        let __v_7: G = (__v_5 + __v_6);
-        let __ret: [G; OUT_201] = [__v_7];
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_201] = [__v_1];
         record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3]; 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_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_201] = [__v_6];
+        record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -18599,42 +18389,37 @@ fn aiur_fn_202(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_202] = [__v_1];
         record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_11, __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_13: G = __r_arr[0];
-        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_202] = [__v_14];
+      _ => {
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        let __v_5: G = __loaded[3];
+        let __v_6: G = __loaded[4];
+        let __v_7: G = __loaded[5];
+        let __v_8: G = __loaded[6];
+        let __v_9: G = __loaded[7];
+        let __v_10: G = __loaded[8];
+        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __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_11: G = __r_arr[0];
+        let __v_12: G = { let __values: [G; 9] = [__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(&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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_202] = [__v_12];
         record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
 const INPUT_SIZE_203: usize = 1;
 const IN_203: usize = 1;
-const OUT_203: usize = 8;
+const OUT_203: usize = 1;
 fn aiur_fn_203(
   inp: [G; IN_203],
   record: &mut QueryRecord,
@@ -18643,49 +18428,24 @@ fn aiur_fn_203(
 ) -> 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 };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_203] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
-        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        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 __v_5: G = __r_arr[1];
-        let __v_6: G = __r_arr[2];
-        let __v_7: G = __r_arr[3];
-        let __v_8: G = __r_arr[4];
-        let __v_9: G = __r_arr[5];
-        let __v_10: G = __r_arr[6];
-        let __v_11: G = __r_arr[7];
-        let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __v_13: G = __r_arr[1];
-        let __v_14: G = __r_arr[2];
-        let __v_15: G = __r_arr[3];
-        let __v_16: G = __r_arr[4];
-        let __v_17: G = __r_arr[5];
-        let __v_18: G = __r_arr[6];
-        let __v_19: G = __r_arr[7];
-        let __ret: [G; OUT_203] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_203] = [__v_1];
         record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        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_3: G = __r_arr[0];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_3 + __v_4);
+        let __ret: [G; OUT_203] = [__v_5];
+        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -18703,28 +18463,23 @@ fn aiur_fn_204(
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
+    match __v_0.as_canonical_u64() {
+      0u64 => {
         let __ret: [G; OUT_204] = [__v_1];
         record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __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_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_204] = [__v_7];
+      _ => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3, __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_4: G = __r_arr[0];
+        let __v_5: G = { let __values: [G; 2] = [__v_2, __v_4]; 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() + 1); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_204] = [__v_5];
         record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
@@ -18752,18 +18507,24 @@ fn aiur_fn_205(
         let __v_3: G = (__v_1 - __v_2);
         let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
+        match __v_4.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_205] = [__v_7];
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
+            if (__v_5 != __v_6) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_205] = [__v_5];
             record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_5: G = __loaded[0];
+            let __v_6: G = __loaded[1];
+            let __ret: [G; OUT_205] = [__v_6];
+            record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
@@ -18782,32 +18543,28 @@ fn aiur_fn_206(
 ) -> Result<[G; OUT_206], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_206] = [__v_8];
-        record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__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_8: G = __r_arr[0];
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = (__v_8 + __v_9);
-        let __ret: [G; OUT_206] = [__v_10];
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_206] = [__v_1];
         record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_6]; 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_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_206] = [__v_9];
+        record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -18824,35 +18581,31 @@ fn aiur_fn_207(
 ) -> Result<[G; OUT_207], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_207] = [__v_11];
-        record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_10]; 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_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_207] = [__v_13];
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_207] = [__v_1];
         record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __v_8: G = __loaded[7];
+        let __v_9: G = __loaded[8];
+        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = (__v_10 + __v_11);
+        let __ret: [G; OUT_207] = [__v_12];
+        record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -18872,21 +18625,27 @@ fn aiur_fn_208(
     let __v_1: G = inp[1];
     let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    match __v_3.as_canonical_u64() {
+    match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_208] = [__v_4, __v_5, __v_6, __v_7];
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(1);
+        if (__v_3 != __v_4) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_208] = [__v_3, __v_3, __v_3, __v_3];
         record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        let __v_7: G = __loaded[4];
+        let __ret: [G; OUT_208] = [__v_3, __v_4, __v_5, __v_6];
+        record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -18903,33 +18662,29 @@ fn aiur_fn_209(
 ) -> Result<[G; OUT_209], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_209] = [__v_9];
-        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !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_9: G = __r_arr[0];
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = (__v_9 + __v_10);
-        let __ret: [G; OUT_209] = [__v_11];
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_209] = [__v_1];
         record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+        let __v_1: G = __loaded[0];
+        let __v_2: G = __loaded[1];
+        let __v_3: G = __loaded[2];
+        let __v_4: G = __loaded[3];
+        let __v_5: G = __loaded[4];
+        let __v_6: G = __loaded[5];
+        let __v_7: G = __loaded[6];
+        let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !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_8: G = __r_arr[0];
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = (__v_8 + __v_9);
+        let __ret: [G; OUT_209] = [__v_10];
+        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -18949,49 +18704,55 @@ fn aiur_fn_210(
     let __v_1: G = inp[1];
     let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    let __v_9: G = __loaded[6];
-    let __v_10: G = __loaded[7];
-    let __v_11: G = __loaded[8];
-    let __v_12: G = __loaded[9];
-    let __v_13: G = __loaded[10];
-    let __v_14: G = __loaded[11];
-    let __v_15: G = __loaded[12];
-    let __v_16: G = __loaded[13];
-    let __v_17: G = __loaded[14];
-    let __v_18: G = __loaded[15];
-    let __v_19: G = __loaded[16];
-    let __v_20: G = __loaded[17];
-    let __v_21: G = __loaded[18];
-    let __v_22: G = __loaded[19];
-    let __v_23: G = __loaded[20];
-    let __v_24: G = __loaded[21];
-    let __v_25: G = __loaded[22];
-    let __v_26: G = __loaded[23];
-    let __v_27: G = __loaded[24];
-    let __v_28: G = __loaded[25];
-    let __v_29: G = __loaded[26];
-    let __v_30: G = __loaded[27];
-    let __v_31: G = __loaded[28];
-    let __v_32: G = __loaded[29];
-    let __v_33: G = __loaded[30];
-    let __v_34: G = __loaded[31];
-    let __v_35: G = __loaded[32];
-    let __v_36: G = __loaded[33];
-    match __v_3.as_canonical_u64() {
+    match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_210] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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 __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(1);
+        if (__v_3 != __v_4) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+        }
+        let __ret: [G; OUT_210] = [__v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3];
         record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        let __loaded: [G; 33] = { let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 33 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 33] = __args[..33].try_into().unwrap(); __arr };
+        let __v_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        let __v_7: G = __loaded[4];
+        let __v_8: G = __loaded[5];
+        let __v_9: G = __loaded[6];
+        let __v_10: G = __loaded[7];
+        let __v_11: G = __loaded[8];
+        let __v_12: G = __loaded[9];
+        let __v_13: G = __loaded[10];
+        let __v_14: G = __loaded[11];
+        let __v_15: G = __loaded[12];
+        let __v_16: G = __loaded[13];
+        let __v_17: G = __loaded[14];
+        let __v_18: G = __loaded[15];
+        let __v_19: G = __loaded[16];
+        let __v_20: G = __loaded[17];
+        let __v_21: G = __loaded[18];
+        let __v_22: G = __loaded[19];
+        let __v_23: G = __loaded[20];
+        let __v_24: G = __loaded[21];
+        let __v_25: G = __loaded[22];
+        let __v_26: G = __loaded[23];
+        let __v_27: G = __loaded[24];
+        let __v_28: G = __loaded[25];
+        let __v_29: G = __loaded[26];
+        let __v_30: G = __loaded[27];
+        let __v_31: G = __loaded[28];
+        let __v_32: G = __loaded[29];
+        let __v_33: G = __loaded[30];
+        let __v_34: G = __loaded[31];
+        let __v_35: G = __loaded[32];
+        let __ret: [G; OUT_210] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34];
+        record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
@@ -19020,19 +18781,25 @@ fn aiur_fn_211(
         let __v_3: G = (__v_1 - __v_2);
         let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0, __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_4: G = __r_arr[0];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        let __v_8: G = __loaded[3];
-        match __v_5.as_canonical_u64() {
+        match __v_4.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_211] = [__v_8];
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
+            if (__v_5 != __v_6) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_211] = [__v_5];
             record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_5: G = __loaded[0];
+            let __v_6: G = __loaded[1];
+            let __v_7: G = __loaded[2];
+            let __ret: [G; OUT_211] = [__v_7];
+            record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
@@ -19063,21 +18830,27 @@ fn aiur_fn_212(
         let __v_3: G = (__v_1 - __v_2);
         let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        let __v_8: G = __loaded[3];
-        let __v_9: G = __loaded[4];
-        let __v_10: G = __loaded[5];
-        match __v_5.as_canonical_u64() {
+        match __v_4.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_212] = [__v_10];
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
+            if (__v_5 != __v_6) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_212] = [__v_5];
             record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+            let __v_5: G = __loaded[0];
+            let __v_6: G = __loaded[1];
+            let __v_7: G = __loaded[2];
+            let __v_8: G = __loaded[3];
+            let __v_9: G = __loaded[4];
+            let __ret: [G; OUT_212] = [__v_9];
+            record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
@@ -19108,49 +18881,55 @@ fn aiur_fn_213(
         let __v_3: G = (__v_1 - __v_2);
         let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __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_4: G = __r_arr[0];
-        let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        let __v_8: G = __loaded[3];
-        let __v_9: G = __loaded[4];
-        let __v_10: G = __loaded[5];
-        let __v_11: G = __loaded[6];
-        let __v_12: G = __loaded[7];
-        let __v_13: G = __loaded[8];
-        let __v_14: G = __loaded[9];
-        let __v_15: G = __loaded[10];
-        let __v_16: G = __loaded[11];
-        let __v_17: G = __loaded[12];
-        let __v_18: G = __loaded[13];
-        let __v_19: G = __loaded[14];
-        let __v_20: G = __loaded[15];
-        let __v_21: G = __loaded[16];
-        let __v_22: G = __loaded[17];
-        let __v_23: G = __loaded[18];
-        let __v_24: G = __loaded[19];
-        let __v_25: G = __loaded[20];
-        let __v_26: G = __loaded[21];
-        let __v_27: G = __loaded[22];
-        let __v_28: G = __loaded[23];
-        let __v_29: G = __loaded[24];
-        let __v_30: G = __loaded[25];
-        let __v_31: G = __loaded[26];
-        let __v_32: G = __loaded[27];
-        let __v_33: G = __loaded[28];
-        let __v_34: G = __loaded[29];
-        let __v_35: G = __loaded[30];
-        let __v_36: G = __loaded[31];
-        let __v_37: G = __loaded[32];
-        let __v_38: G = __loaded[33];
-        match __v_5.as_canonical_u64() {
+        match __v_4.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_213] = [__v_38];
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
+            if (__v_5 != __v_6) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("niche match: nullary constructor not covered".to_string()) });
+            }
+            let __ret: [G; OUT_213] = [__v_5];
             record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            let __loaded: [G; 33] = { let __mq = record.memory_queries.get_mut(&33).ok_or(ExecError::InvalidMemorySize(33))?; 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) = __ptr_usize.checked_sub(1).and_then(|__i| __mq.get_index_mut(__i)).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 33 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 33] = __args[..33].try_into().unwrap(); __arr };
+            let __v_5: G = __loaded[0];
+            let __v_6: G = __loaded[1];
+            let __v_7: G = __loaded[2];
+            let __v_8: G = __loaded[3];
+            let __v_9: G = __loaded[4];
+            let __v_10: G = __loaded[5];
+            let __v_11: G = __loaded[6];
+            let __v_12: G = __loaded[7];
+            let __v_13: G = __loaded[8];
+            let __v_14: G = __loaded[9];
+            let __v_15: G = __loaded[10];
+            let __v_16: G = __loaded[11];
+            let __v_17: G = __loaded[12];
+            let __v_18: G = __loaded[13];
+            let __v_19: G = __loaded[14];
+            let __v_20: G = __loaded[15];
+            let __v_21: G = __loaded[16];
+            let __v_22: G = __loaded[17];
+            let __v_23: G = __loaded[18];
+            let __v_24: G = __loaded[19];
+            let __v_25: G = __loaded[20];
+            let __v_26: G = __loaded[21];
+            let __v_27: G = __loaded[22];
+            let __v_28: G = __loaded[23];
+            let __v_29: G = __loaded[24];
+            let __v_30: G = __loaded[25];
+            let __v_31: G = __loaded[26];
+            let __v_32: G = __loaded[27];
+            let __v_33: G = __loaded[28];
+            let __v_34: G = __loaded[29];
+            let __v_35: G = __loaded[30];
+            let __v_36: G = __loaded[31];
+            let __v_37: G = __loaded[32];
+            let __ret: [G; OUT_213] = [__v_37];
+            record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },